/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package org.cip.esymons.eventos.beans;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.ejb.EJB;
import javax.faces.application.FacesMessage;
import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import org.apache.myfaces.custom.fileupload.UploadedFile;
import org.cip.esymons.eventos.adapaters.CalendarioAmbientesAdapter;
import org.cip.esymons.eventos.adapaters.DetIngresosAdapter;
import org.cip.esymons.eventos.bc.ArchivosDelegate;
import org.cip.esymons.eventos.be.RangoMatriculas;
import org.cip.esymons.eventos.bc.AreaDelegate;
import org.cip.esymons.eventos.bc.CursoDelegate;
import org.cip.esymons.eventos.bc.DetalleConceptoDelegate;
import org.cip.esymons.eventos.bc.DetalleEgresosDelegate;
import org.cip.esymons.eventos.bc.DetalleIngresosDelegate;
import org.cip.esymons.eventos.bc.EstimacionParticipanteDelegate;
import org.cip.esymons.eventos.bc.EventoDelegate;
import org.cip.esymons.eventos.bc.InstructorEventoDelegate;
import org.cip.esymons.eventos.bc.ModeloPresupuestoDelegate;
import org.cip.esymons.eventos.bc.ModuloCursoDelegate;
import org.cip.esymons.eventos.bc.OrganizadorEventoDelegate;
import org.cip.esymons.eventos.bc.PreEventoDelegate;
import org.cip.esymons.eventos.bc.PreeventoAdapter;
import org.cip.esymons.eventos.bc.ReservaAmbienteDelegate;
import org.cip.esymons.eventos.bc.TipoConceptoDelegate;
import org.cip.esymons.eventos.bc.TipoEventoDelegate;
import org.cip.esymons.eventos.bc.TipoIngresosDelegate;
import org.cip.esymons.eventos.bc.TipoParticipanteDelegate;
import org.cip.esymons.eventos.be.Ambiente;
import org.cip.esymons.eventos.be.Archivos;
import org.cip.esymons.eventos.be.Curso;
import org.cip.esymons.eventos.be.DetalleConcepto;
import org.cip.esymons.eventos.be.DetalleEgresos;
import org.cip.esymons.eventos.be.DetalleIngresosEventos;
import org.cip.esymons.eventos.be.EstimacionParticipantes;
import org.cip.esymons.eventos.be.Evento;
import org.cip.esymons.eventos.be.InstructorEvento;
import org.cip.esymons.eventos.be.InstructorModulo;
import org.cip.esymons.eventos.be.ModeloPresupuesto;
import org.cip.esymons.eventos.be.ModuloCurso;
import org.cip.esymons.eventos.be.OrganizadorEvento;
import org.cip.esymons.eventos.be.Preevento;
import org.cip.esymons.eventos.be.ReservaAmbiente;
import org.cip.esymons.eventos.be.ServicioEquipo;
import org.cip.esymons.eventos.be.TipoConcepto;
import org.cip.esymons.eventos.be.TipoEvento;
import org.cip.esymons.eventos.be.TipoIngresoEventos;
import org.cip.esymons.eventos.be.TipoParticipanteEvento;
import org.cip.esymons.general.bc.CapituloFacadeLocal;
import org.cip.esymons.general.bc.EspecialidadCapituloFacadeLocal;
import org.cip.esymons.general.bc.PersonaNaturalDelegate;
import org.cip.esymons.general.bc.SolicitanteDelegate;
import org.cip.esymons.general.be.Area;
import org.cip.esymons.general.be.Capitulo;
import org.cip.esymons.general.be.PersonaNatural;
import org.cip.esymons.general.be.Solicitante;
import org.cip.esymons.general.util.ControladorAbstracto;
import org.cip.esymons.general.util.Utiles;
import org.cip.esymons.tramite.be.Expediente;
import org.cip.esymons.tramite.be.Tramite;
import org.cip.esymons.tramite.be.Transaccion;

/**
 *
 * @author OscarA
 */
public class PreEventoController {

    //<editor-fold defaultstate="collapsed" desc="Variables de Inicio">
    @EJB
    private CapituloFacadeLocal capituloFacade;
    private AreaDelegate areaFacade;
    @EJB
    private EspecialidadCapituloFacadeLocal especialidadCapituloFacade;
    List<TipoParticipanteEvento> listaTParticipantes;
    List<TipoParticipanteEvento> listaTParticipantes1;
    TipoIngresoEventos tipoIngreso;
    TipoParticipanteDelegate delegateTipoParticipante;
    List<DetIngresosAdapter> listaIngresosAdapter;
    List<RangoMatriculas> listaRangos;
    RangoMatriculas rangoSeleccionado;
    PreEventoDelegate delegate;
    EstimacionParticipanteDelegate delegateEstimacion;
    EventoDelegate delegateEvento;
    CursoDelegate delegateCurso;
    Preevento preEvento;
    Preevento preEventoVerifContenido;
    Preevento preEventoVerifPresupuesto;
    Preevento preEventoTramitar;
    List<EstimacionParticipantes> listaEstimacionParticipantes;
    boolean busq = false;
    String dni = "";
    Preevento preEventoSeleccionado;
    List<Preevento> listaPreEventos;
    List<Preevento> listaPreEventosPresupuesto;
    List<Preevento> listaPreEventosVerifContenido;
    List<Preevento> listaPreEventosVerifPresupuesto;
    List<Preevento> listaPreEventosPorTramitar;
    List<Preevento> listaPreEventosAprobados;
    InstructorEventoDelegate delegateInstructor;
    OrganizadorEventoDelegate delegateOrganizador;
    List<DetalleConcepto> listaDetalleConcepto;
    DetalleConceptoDelegate delegateDetConcepto;
    PersonaNaturalDelegate delegatePersona;
    Date fechaInicio;
    Date fechaFin;
    ModeloPresupuestoDelegate delegatePresupuesto;
    boolean tieneCertificado = false;
    boolean tieneMatricula = false;
    boolean tieneMensualidad = false;
    List<InstructorEvento> listaInstructores;
    ReservaAmbienteDelegate delegateReserva;
    InstructorEvento instructorSeleccionado;
    String tipoOrganizador;
    String tipoPersona;
    String capituloSeleccionado;
    DetalleEgresosDelegate delegateDetEgresos;
    String areaSeleccionada;
    List<OrganizadorEvento> listaOrganizadores;
    List<OrganizadorEvento> listaOrganizadores1;
    OrganizadorEvento organizadorEvento;
    String coorganizador;
    Double utilidad = new Double(0);
    Double ingresos = new Double(0);
    Double egresos = new Double(0);
    List<DetalleConcepto> listadetalleEgresos;
    String tipoAmbiente = "1";
    Date fechaAmbiente = null;
    List<Preevento> listarPresupuestados;
    PersonaNatural persona;
    int cont = 0;
    List<ModeloPresupuesto> listaPresupuestos;
    TipoIngresosDelegate delegateTIngresos;
    String editor = "<ol> </ol><p><strong>1. OBJETIVO GENERAL<br /></strong></p><ul><li>Objetivo General</li>" +
            "</ul><p><strong>2. OBJETIVOS ESPECIFICOS<br /></strong></p><ul><li>objetivo1</li><li>objetivo2</li><li>objetivo3</li>" +
            "</ul><p><strong>3. REQUISITOS</strong></p><ul><li>Requisito1</li><li>Requisito2</li><li>Requisito3</li></ul>" +
            "<p><strong>4. TEMARIO</strong></p><ol><li>Modulo 1</li><li>Modulo 2</li><li>Modulo 3</li></ol><p><strong>5: INCLUYE</strong></p>" +
            "<ul><li>Material 1</li><li>Material 2</li></ul><p><strong>6: FORMAS DE PAGO</strong></p><ul><li>Forma pago 1</li>" +
            "<li>Forma pago 2</li><li>Forma pago 3</li></ul><p><strong>7. INFORMES</strong></p><ul><li>LLamar al 00000</li>" +
            "<li>Para m&aacute;s informaci&oacute;n visitar www.cip-trujillo.org</li></ul>";
    List<TipoIngresoEventos> listaIngresos;
    List<TipoIngresoEventos> listaIngresos1;
    List<TipoIngresoEventos> listaIngresos2;
    Date fechaR1Inicio;
    Date fechaR1Fin;
    Ambiente ambiente;
    ServicioEquipo equipo;
    List<CalendarioAmbientesAdapter> listaCalendario;
    List<CalendarioAmbientesAdapter> listaCalendario1;
    List<DetalleIngresosEventos> listaDetalleIngresos;
    CalendarioAmbientesAdapter ambienteSeleccionado;
    Preevento preEventoPresupuesto;
    int nroModulos = 4;
    int minimo = 1;
    int maximo = 8;
    int nroMeses = 6;
    int minimoMeses = 1;
    int maximoMeses = 24;
    List<DetalleEgresos> listaEgresos;
    private DetalleIngresosDelegate delegateDetIngresos;
    //Lizardo
    private ModuloCurso modulo;
    private Curso curso;
    private List<ModuloCurso> listaModulo;
    private List<InstructorModulo> listaInstructorModulo;
    private InstructorModulo instructorModulo;
    private Integer ineCodigo;
    String temarioModulo = "<ol> </ol><p><strong>1. CONTENIDOS<br /></strong></p>" +
            "<ol><li>Contenido 1</li><li>Contenido 2</li>" +
            "<li>Contenido 3</li></ol><p><strong>2: INCLUYE</strong></p>" +
            "<ul><li>Material 1</li><li>Material 2</li></ul></ul>";
    String totalAprobados;
    String totalPreeventos;
    private Boolean modal;
    Long codPersona;

    TipoConcepto tipoConcepto;
    DetalleConcepto detalleConcepto;
    Integer tpcCodigo;

    //Fin Lizardo
    // // </editor-fold>
    //CASTOR
    private ArchivosDelegate delegadoArchivos;
    private Archivos archivos;
    private List<Archivos> listaArchivosMaterial;
    private List<Archivos> listaContenidoPresupuesto;
    private Boolean agregarDatos;
    private String rutaArchivo;
    private String nombreArchivo;
   private Integer tipoArchivo;

    //FIN CASTOR
    public PreEventoController() {
        inicializar();
    }

    //<editor-fold defaultstate="collapsed" desc="Inicializar">
    public String inicializar() {
        tipoIngreso = new TipoIngresoEventos();
        listaOrganizadores1 = new ArrayList<OrganizadorEvento>();
        rangoSeleccionado = new RangoMatriculas();
        delegateEstimacion = new EstimacionParticipanteDelegate();
        listaIngresos2 = new ArrayList<TipoIngresoEventos>();
        listaEstimacionParticipantes = new ArrayList<EstimacionParticipantes>();
        listaDetalleIngresos = new ArrayList<DetalleIngresosEventos>();
        preEventoPresupuesto = new Preevento();
        preEvento = new Preevento();
        delegateDetIngresos = new DetalleIngresosDelegate();
        areaFacade = new AreaDelegate();
        delegateEvento = new EventoDelegate();
        delegateCurso = new CursoDelegate();
        preEventoVerifContenido = new Preevento();
        preEventoVerifPresupuesto = new Preevento();
        preEventoTramitar = new Preevento();
        listaPreEventos = new ArrayList<Preevento>();
        listaPreEventosPresupuesto = new ArrayList<Preevento>();
        listaPreEventosVerifContenido = new ArrayList<Preevento>();
        listaPreEventosVerifPresupuesto = new ArrayList<Preevento>();
        listaPreEventosAprobados = new ArrayList<Preevento>();
        listaPreEventosPorTramitar = new ArrayList<Preevento>();
        delegate = new PreEventoDelegate();
        delegateDetConcepto = new DetalleConceptoDelegate();
        delegateInstructor = new InstructorEventoDelegate();
        delegateOrganizador = new OrganizadorEventoDelegate();
        persona = new PersonaNatural();
        listaPresupuestos = new ArrayList<ModeloPresupuesto>();
        listaEgresos = new ArrayList<DetalleEgresos>();
        delegatePersona = new PersonaNaturalDelegate();
        delegateDetEgresos = new DetalleEgresosDelegate();
        instructorSeleccionado = new InstructorEvento();
        ambienteSeleccionado = new CalendarioAmbientesAdapter();
        listaInstructores = new ArrayList<InstructorEvento>();
        listaOrganizadores = new ArrayList<OrganizadorEvento>();
        listadetalleEgresos = new ArrayList<DetalleConcepto>();
        delegateTipoParticipante = new TipoParticipanteDelegate();
        listaCalendario1 = new ArrayList<CalendarioAmbientesAdapter>();
        delegatePresupuesto = new ModeloPresupuestoDelegate();
        listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
        delegateReserva = new ReservaAmbienteDelegate();
        listaRangos = new ArrayList<RangoMatriculas>();
        listarModeloPresupuesto();
        listarPreeventos();
        cargarEventosPresupuesto();
        listaIngresosAdapter = new ArrayList<DetIngresosAdapter>();
        cargarEventosVerifPresupuesto();
        cargarEventosVerifContenido();
        cargarEventosPorTramitar();
        cargarEventosAprobados();
        preEventoSeleccionado = new Preevento();
        listarPresupuestados = new ArrayList<Preevento>();
        ingresos = egresos = utilidad = 0.0;
        fechaAmbiente = new Date();
        fechaAmbiente = fechaR1Fin = fechaR1Inicio = null;
        listaIngresos = new ArrayList<TipoIngresoEventos>();
        listaIngresos1 = new ArrayList<TipoIngresoEventos>();
        delegateTIngresos = new TipoIngresosDelegate();
        listaTParticipantes = new ArrayList<TipoParticipanteEvento>();
        listaTParticipantes1 = new ArrayList<TipoParticipanteEvento>();
        cargarTipoPartIng();
        //Lizardo
        curso = new Curso();
        modulo = new ModuloCurso();
        listaModulo = new ArrayList<ModuloCurso>();
        detalleConcepto = new DetalleConcepto();
        tipoConcepto = new TipoConcepto();
        //Fin Lizardo

        //CASTOR
        archivos = new Archivos();
        delegadoArchivos = new ArchivosDelegate();
        listaArchivosMaterial = new ArrayList<Archivos>();
        listaArchivosMaterial = null;
        listaContenidoPresupuesto = new ArrayList<Archivos>();
        listaContenidoPresupuesto = null;
        agregarDatos = false;
        rutaArchivo = "D:\\Archivos\\"; //ruta windows
        //rutaArchivo = "/modulos/eventos/archivos/";  //ruta Linux
        //FIN CASTOR
        return "";
    }

    //hecho por lizardo
    public String inicializarAmbientes() {
        fechaAmbiente = null;
        listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
        listaCalendario1 = new ArrayList<CalendarioAmbientesAdapter>();
        return null;
    }

    public String registrarDetalleConcepto() {
        try {
            DetalleConceptoDelegate delegadoDetalleConcepto = new DetalleConceptoDelegate();
            TipoConceptoDelegate delegadoTipoConcepto = new TipoConceptoDelegate();
            tpcCodigo = (tpcCodigo != null) ? tpcCodigo : 0;
            tipoConcepto = delegadoTipoConcepto.buscarTipoConcepto(tpcCodigo);
            detalleConcepto.setTpcCodigo(tipoConcepto);
            detalleConcepto.setDcoEstado(true);
            delegadoDetalleConcepto.guardar(detalleConcepto);
            detalleConcepto = new DetalleConcepto();
            tipoConcepto = new TipoConcepto();
            listarModeloPresupuesto();
        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "No se puede registrar los detalles conceptos", FacesMessage.SEVERITY_ERROR);
            System.out.println("FATAL: " + ex.getMessage());
        }
        return null;
    }

    public String listarPreeventos() {
        try {
            listaPreEventos = delegate.listarTodosxUsuarios();
            totalPreeventos = Utiles.totalRegistro(listaPreEventos, "evento(s) en lista");
            if (listaPreEventos.size() < 1) {
                mostrarMensaje("Advertencia", "No hay Pre-Eventos Registrados", FacesMessage.SEVERITY_INFO);
            }
        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
        }
        return "";
    }

    public String cargarEventosVerifPresupuesto() {
        try {
            listaPreEventosVerifPresupuesto = new ArrayList<Preevento>();
            listaPreEventosVerifPresupuesto = delegate.listarVerificarPresupuesto();
        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
        }
        return "";
    }

    public String cargarEventosVerifContenido() {
        try {
            listaPreEventosVerifContenido = new ArrayList<Preevento>();
            listaPreEventosVerifContenido = delegate.listarVerificarContenidos();
        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
        }
        return "";
    }

    public String cargarEventosPorTramitar() {
        try {
            listaPreEventosPorTramitar = new ArrayList<Preevento>();
            listaPreEventosPorTramitar = delegate.listarEventosPorTramitar();
        } catch (Exception e) {
        }
        return "";
    }

    private String cargarEventosAprobados() {
        try {
            listaPreEventosAprobados = new ArrayList<Preevento>();
            listaPreEventosAprobados = delegate.listarEventosAprobados();
            totalAprobados = Utiles.totalRegistro(listaPreEventosAprobados, "evento(s) aprobados en lista");
        } catch (Exception e) {
        }
        return "";
    }

    public String cargarTipoPartIng() {
        try {
            listaTParticipantes1.clear();
            listaTParticipantes = delegateTipoParticipante.listarTodos();
            System.out.println("Hola Part ");
        } catch (Exception e) {
            System.out.print("Error en " + e.toString());
        }
        try {
            //listaIngresos1.clear();   //oscar chistozo eres con esto tambien limpiar a listaIngreso2!!!
            listaIngresos.clear();
            listaIngresos = delegateTIngresos.listar_Todos();
            System.out.println("Ing ");
        } catch (Exception e) {
            System.out.print("Error ing en " + e.toString());
        }
        return null;
    }

    public Archivos getArchivos() {
        return archivos;
    }

    public void setArchivos(Archivos archivos) {
        this.archivos = archivos;
    }
  //CASTOR    

    public List<Archivos> getListaArchivosMaterial() {
        return listaArchivosMaterial;
    }

    public void setListaArchivosMaterial(List<Archivos> listaArchivosMaterial) {
        this.listaArchivosMaterial = listaArchivosMaterial;
    }

    public Boolean getAgregarDatos() {
        return agregarDatos;
    }

    public void setAgregarDatos(Boolean agregarDatos) {
        this.agregarDatos = agregarDatos;
    }

    public ArchivosDelegate getDelegadoArchivos() {
        return delegadoArchivos;
    }

    public void setDelegadoArchivos(ArchivosDelegate delegadoArchivos) {
        this.delegadoArchivos = delegadoArchivos;
    }

    public String getRutaArchivo() {
        return rutaArchivo;
    }

    public void setRutaArchivo(String rutaArchivo) {
        this.rutaArchivo = rutaArchivo;
    }

    public List<Archivos> getListaContenidoPresupuesto() {
        return listaContenidoPresupuesto;
    }

    public void setListaContenidoPresupuesto(List<Archivos> listaContenidoPresupuesto) {
        this.listaContenidoPresupuesto = listaContenidoPresupuesto;
    }

    public String getNombreArchivo() {
        return nombreArchivo;
    }

    public void setNombreArchivo(String nombreArchivo) {
        this.nombreArchivo = nombreArchivo;
    }

    public Integer getTipoArchivo() {
        return tipoArchivo;
    }

    public void setTipoArchivo(Integer tipoArchivo) {
        this.tipoArchivo = tipoArchivo;
    }
//FIN CASTOR
    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="GET and SET">



    
    public String getTotalAprobados() {
        return totalAprobados;
    }

    public int getMaximoMeses() {
        return maximoMeses;
    }

    public void setMaximoMeses(int maximoMeses) {
        this.maximoMeses = maximoMeses;
    }

    public int getMinimoMeses() {
        return minimoMeses;
    }

    public void setMinimoMeses(int minimoMeses) {
        this.minimoMeses = minimoMeses;
    }

    public int getNroMeses() {
        return nroMeses;
    }

    public void setNroMeses(int nroMeses) {
        this.nroMeses = nroMeses;
    }

    public void setTotalAprobados(String totalAprobados) {
        this.totalAprobados = totalAprobados;
    }

    public TipoConcepto getTipoConcepto() {
        return tipoConcepto;
    }

    public void setTipoConcepto(TipoConcepto tipoConcepto) {
        this.tipoConcepto = tipoConcepto;
    }

    public Integer getTpcCodigo() {
        return tpcCodigo;
    }

    public void setTpcCodigo(Integer tpcCodigo) {
        this.tpcCodigo = tpcCodigo;
    }

    

    public DetalleConcepto getDetalleConcepto() {
        return detalleConcepto;
    }

    public void setDetalleConcepto(DetalleConcepto detalleConcepto) {
        this.detalleConcepto = detalleConcepto;
    }



    public Long getCodPersona() {
        return codPersona;
    }

    public void setCodPersona(Long codPersona) {
        this.codPersona = codPersona;
    }

    public Boolean getModal() {
        return modal;
    }

    public void setModal(Boolean modal) {
        this.modal = modal;
    }

    public String getTotalPreeventos() {
        return totalPreeventos;
    }

    public void setTotalPreeventos(String totalPreeventos) {
        this.totalPreeventos = totalPreeventos;
    }

    public List<Preevento> getListaPreEventos() {
        //listarPreeventos();
        return listaPreEventos;
    }

    public TipoIngresoEventos getTipoIngreso() {
        return tipoIngreso;
    }

    public void setTipoIngreso(TipoIngresoEventos tipoIngreso) {
        this.tipoIngreso = tipoIngreso;
    }

    public RangoMatriculas getRangoSeleccionado() {
        return rangoSeleccionado;
    }

    public void setRangoSeleccionado(RangoMatriculas rangoSeleccionado) {
        this.rangoSeleccionado = rangoSeleccionado;
    }

    public List<TipoIngresoEventos> getListaIngresos2() {
        return listaIngresos2;
    }

    public void setListaIngresos2(List<TipoIngresoEventos> listaIngresos2) {
        this.listaIngresos2 = listaIngresos2;
    }

    public List<DetIngresosAdapter> getListaIngresosAdapter() {
        return listaIngresosAdapter;
    }

    public void setListaIngresosAdapter(List<DetIngresosAdapter> listaIngresosAdapter) {
        this.listaIngresosAdapter = listaIngresosAdapter;
    }

    public List<EstimacionParticipantes> getListaEstimacionParticipantes() {
        return listaEstimacionParticipantes;
    }

    public void setListaEstimacionParticipantes(List<EstimacionParticipantes> listaEstimacionParticipantes) {
        this.listaEstimacionParticipantes = listaEstimacionParticipantes;
    }

    public List<DetalleIngresosEventos> getListaDetalleIngresos() {
        return listaDetalleIngresos;
    }

    public void setListaDetalleIngresos(List<DetalleIngresosEventos> listaDetalleIngresos) {
        this.listaDetalleIngresos = listaDetalleIngresos;
    }

    public List<RangoMatriculas> getListaRangos() {
        return listaRangos;
    }

    public void setListaRangos(List<RangoMatriculas> listaRangos) {
        this.listaRangos = listaRangos;
    }

    public List<TipoParticipanteEvento> getListaTParticipantes() {
        return listaTParticipantes;
    }

    public void setListaTParticipantes(List<TipoParticipanteEvento> listaTParticipantes) {
        this.listaTParticipantes = listaTParticipantes;
    }

    public List<TipoParticipanteEvento> getListaTParticipantes1() {
        return listaTParticipantes1;
    }

    public void setListaTParticipantes1(List<TipoParticipanteEvento> listaTParticipantes1) {
        this.listaTParticipantes1 = listaTParticipantes1;
    }

    public Preevento getPreEventoTramitar() {
        return preEventoTramitar;
    }

    public List<TipoIngresoEventos> getListaIngresos() {
        cargarTipoPartIng();
        return listaIngresos;
    }

    public void setListaIngresos(List<TipoIngresoEventos> listaIngresos) {
        this.listaIngresos = listaIngresos;
    }

    public List<TipoIngresoEventos> getListaIngresos1() {
        return listaIngresos1;
    }

    public void setListaIngresos1(List<TipoIngresoEventos> listaIngresos1) {
        this.listaIngresos1 = listaIngresos1;
    }

    public void setPreEventoTramitar(Preevento preEventoTramitar) {
        this.preEventoTramitar = preEventoTramitar;
    }

    public List<Preevento> getListaPreEventosPorTramitar() {
        return listaPreEventosPorTramitar;
    }

    public void setListaPreEventosPorTramitar(List<Preevento> listaPreEventosPorTramitar) {
        this.listaPreEventosPorTramitar = listaPreEventosPorTramitar;
    }

    public Preevento getPreEventoVerifContenido() {
        return preEventoVerifContenido;
    }

    public void setPreEventoVerifContenido(Preevento preEventoVerifContenido) {
        this.preEventoVerifContenido = preEventoVerifContenido;
    }

    public Preevento getPreEventoVerifPresupuesto() {
        return preEventoVerifPresupuesto;
    }

    public void setPreEventoVerifPresupuesto(Preevento preEventoVerifPresupuesto) {
        this.preEventoVerifPresupuesto = preEventoVerifPresupuesto;
    }

    public List<Preevento> getListaPreEventosPresupuesto() {
        return listaPreEventosPresupuesto;
    }

    public List<Preevento> getListaPreEventosVerifContenido() {
        return listaPreEventosVerifContenido;
    }

    public void setListaPreEventosVerifContenido(List<Preevento> listaPreEventosVerifContenido) {
        this.listaPreEventosVerifContenido = listaPreEventosVerifContenido;
    }

    public List<Preevento> getListaPreEventosVerifPresupuesto() {
        return listaPreEventosVerifPresupuesto;
    }

    public void setListaPreEventosVerifPresupuesto(List<Preevento> listaPreEventosVerifPresupuesto) {
        this.listaPreEventosVerifPresupuesto = listaPreEventosVerifPresupuesto;
    }

    public void setListaPreEventosPresupuesto(List<Preevento> listaPreEventosPresupuesto) {
        this.listaPreEventosPresupuesto = listaPreEventosPresupuesto;
    }

    public List<ModeloPresupuesto> getListaPresupuestos() {
        return listaPresupuestos;
    }

    public void setListaPresupuestos(List<ModeloPresupuesto> listaPresupuestos) {
        this.listaPresupuestos = listaPresupuestos;
    }

    public PersonaNatural getPersona() {
        return persona;
    }

    public String getDni() {
        return dni;
    }

    public void setDni(String dni) {
        this.dni = dni;
    }

    public void setPersona(PersonaNatural persona) {
        this.persona = persona;
    }

    public int getMaximo() {
        return maximo;
    }

    public void setMaximo(int maximo) {
        this.maximo = maximo;
    }

    public int getMinimo() {
        return minimo;
    }

    public void setMinimo(int minimo) {
        this.minimo = minimo;
    }

    public int getNroModulos() {
        return nroModulos;
    }

    public void setNroModulos(int nroModulos) {
        this.nroModulos = nroModulos;
    }

    public CalendarioAmbientesAdapter getAmbienteSeleccionado() {
        return ambienteSeleccionado;
    }

    public void setAmbienteSeleccionado(CalendarioAmbientesAdapter ambienteSeleccionado) {
        this.ambienteSeleccionado = ambienteSeleccionado;
    }

    public Preevento getPreEventoPresupuesto() {
        return preEventoPresupuesto;
    }

    public void setPreEventoPresupuesto(Preevento preEventoPresupuesto) {
        this.preEventoPresupuesto = preEventoPresupuesto;
    }

    public List<CalendarioAmbientesAdapter> getListaCalendario() {
        return listaCalendario;
    }

    public List<CalendarioAmbientesAdapter> getListaCalendario1() {
        return listaCalendario1;
    }

    public void setListaCalendario1(List<CalendarioAmbientesAdapter> listaCalendario1) {
        this.listaCalendario1 = listaCalendario1;
    }

    public List<Preevento> getListarPresupuestados() {
        try {
            listarPresupuestados = delegate.listarDesaprobadosPresupuesto();
        } catch (Exception ex) {
            Logger.getLogger(PreEventoController.class.getName()).log(Level.SEVERE, null, ex);
        }
        return listarPresupuestados;
    }

    public void setListarPresupuestados(List<Preevento> listarPresupuestados) {
        this.listarPresupuestados = listarPresupuestados;
    }

    public Preevento getPreEventoSeleccionado() {
        return preEventoSeleccionado;
    }

    public void setPreEventoSeleccionado(Preevento preEventoSeleccionado) {
        this.preEventoSeleccionado = preEventoSeleccionado;
    }

    public void setListaCalendario(List<CalendarioAmbientesAdapter> listaCalendario) {
        this.listaCalendario = listaCalendario;
    }

    public ServicioEquipo getEquipo() {
        return equipo;
    }

    public void setEquipo(ServicioEquipo equipo) {
        this.equipo = equipo;
    }

    public Ambiente getAmbiente() {
        return ambiente;
    }

    public void setAmbiente(Ambiente ambiente) {
        this.ambiente = ambiente;
    }

    public Date getFechaAmbiente() {
        return fechaAmbiente;
    }

    public void setFechaAmbiente(Date fechaAmbiente) {
        this.fechaAmbiente = fechaAmbiente;
    }

    public String getTipoAmbiente() {
        return tipoAmbiente;
    }

    public void setTipoAmbiente(String tipoAmbiente) {
        this.tipoAmbiente = tipoAmbiente;
    }

    public Date getFechaR1Fin() {
        return fechaR1Fin;
    }

    public void setFechaR1Fin(Date fechaR1Fin) {
        this.fechaR1Fin = fechaR1Fin;
    }

    public Date getFechaR1Inicio() {
        return fechaR1Inicio;
    }

    public void setFechaR1Inicio(Date fechaR1Inicio) {
        this.fechaR1Inicio = fechaR1Inicio;
    }

    public void setListaPreEventos(List<Preevento> listaPreEventos) {
        this.listaPreEventos = listaPreEventos;
    }

    public OrganizadorEvento getOrganizadorEvento() {
        return organizadorEvento;
    }

    public List<DetalleConcepto> getListadetalleEgresos() {
        return listadetalleEgresos;
    }

    public void setListadetalleEgresos(List<DetalleConcepto> listadetalleEgresos) {
        this.listadetalleEgresos = listadetalleEgresos;
    }

    public String getEditor() {
        return editor;
    }

    public void setEditor(String editor) {
        this.editor = editor;
    }

    public Double getEgresos() {
        return egresos;
    }

    public void setEgresos(Double egresos) {
        this.egresos = egresos;
    }

    public List<Preevento> getListaPreEventosAprobados() {
        return listaPreEventosAprobados;
    }

    public void setListaPreEventosAprobados(List<Preevento> listaPreEventosAprobados) {
        this.listaPreEventosAprobados = listaPreEventosAprobados;
    }

    public Double getIngresos() {
        return ingresos;
    }

    public void setIngresos(Double ingresos) {
        this.ingresos = ingresos;
    }

    public Double getUtilidad() {
        return utilidad;
    }

    public void setUtilidad(Double utilidad) {
        this.utilidad = utilidad;
    }

    public void setOrganizadorEvento(OrganizadorEvento organizadorEvento) {
        this.organizadorEvento = organizadorEvento;
    }

    public String getCoorganizador() {
        return coorganizador;
    }

    public void setCoorganizador(String coorganizador) {
        this.coorganizador = coorganizador;
    }

    public boolean isTieneMatricula() {
        return tieneMatricula;
    }

    public String getTipoPersona() {
        return tipoPersona;
    }

    public void setTipoPersona(String tipoPersona) {
        this.tipoPersona = tipoPersona;
    }

    public List<OrganizadorEvento> getListaOrganizadores() {
        return listaOrganizadores;
    }

    public void setListaOrganizadores(List<OrganizadorEvento> listaOrganizadores) {
        this.listaOrganizadores = listaOrganizadores;
    }

    public String getAreaSeleccionada() {
        return areaSeleccionada;
    }

    public void setAreaSeleccionada(String areaSeleccionada) {
        this.areaSeleccionada = areaSeleccionada;
    }

    public String getCapituloSeleccionado() {
        return capituloSeleccionado;
    }

    public void setCapituloSeleccionado(String capituloSeleccionado) {
        this.capituloSeleccionado = capituloSeleccionado;
    }

    public String getTipoOrganizador() {
        return tipoOrganizador;
    }

    public void setTipoOrganizador(String tipoOrganizador) {
        this.tipoOrganizador = tipoOrganizador;
    }

    public InstructorEvento getInstructorSeleccionado() {
        return instructorSeleccionado;
    }

    public void setInstructorSeleccionado(InstructorEvento instructorSeleccionado) {
        this.instructorSeleccionado = instructorSeleccionado;
    }

    public List<InstructorEvento> getListaInstructores() {
        return listaInstructores;
    }

    public void setListaInstructores(List<InstructorEvento> listaInstructores) {
        this.listaInstructores = listaInstructores;
    }

    public void setTieneMatricula(boolean tieneMatricula) {
        if (tieneMatricula) {
            this.tieneMatricula = false;
        } else {
            this.tieneMatricula = true;
        }
    }

    public boolean isTieneMensualidad() {
        return tieneMensualidad;
    }

    public void setTieneMensualidad(boolean tieneMensualidad) {
        if (tieneMensualidad) {
            this.tieneMensualidad = false;
        } else {
            this.tieneMensualidad = true;
        }
    }

    public boolean isTieneCertificado() {
        return tieneCertificado;
    }

    public void setTieneCertificado(boolean tieneCertificado) {
        if (tieneCertificado) {
            this.tieneCertificado = false;
        } else {
            this.tieneCertificado = true;
        }
    }

    public Date getFechaFin() {
        return fechaFin;
    }

    public void setFechaFin(Date fechaFin) {
        this.fechaFin = fechaFin;
    }

    public Date getFechaInicio() {
        return fechaInicio;
    }

    public void setFechaInicio(Date fechaInicio) {
        this.fechaInicio = fechaInicio;
    }

    public List<DetalleConcepto> getListaDetalleConcepto() {
        return listaDetalleConcepto;
    }

    public void setListaDetalleConcepto(List<DetalleConcepto> listaDetalleConceptoMT) {
        this.listaDetalleConcepto = listaDetalleConceptoMT;
    }

    public Preevento getPreEvento() {
        return preEvento;
    }

    public void setPreEvento(Preevento preEvento) {
        this.preEvento = preEvento;
    }

    //Lizardo
    public ModuloCurso getModulo() {
        return modulo;
    }

    public void setModulo(ModuloCurso modulo) {
        this.modulo = modulo;
    }

    public Curso getCurso() {
        return curso;
    }

    public void setCurso(Curso curso) {
        this.curso = curso;
    }

    public List<InstructorModulo> getListaInstructorModulo() {
        return listaInstructorModulo;
    }

    public void setListaInstructorModulo(List<InstructorModulo> listaInstructorModulo) {
        this.listaInstructorModulo = listaInstructorModulo;
    }

    public List<ModuloCurso> getListaModulo() {
        return listaModulo;
    }

    public void setListaModulo(List<ModuloCurso> listaModulo) {
        this.listaModulo = listaModulo;
    }

    public InstructorModulo getInstructorModulo() {
        return instructorModulo;
    }

    public void setInstructorModulo(InstructorModulo instructorModulo) {
        this.instructorModulo = instructorModulo;
    }

    public Integer getIneCodigo() {
        return ineCodigo;
    }

    public void setIneCodigo(Integer ineCodigo) {
        this.ineCodigo = ineCodigo;
    }

    public String getTemarioModulo() {
        return temarioModulo;
    }

    public void setTemarioModulo(String temarioModulo) {
        this.temarioModulo = temarioModulo;
    }

    //Fin Lizardo
    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Validaciones">
    public boolean validarFechas(Date ini, Date fin) {
        try {
            if (!ini.equals(null)) {
                if (!fin.equals(null)) {
                    if (fin.compareTo(ini) >= 0) {
                        return true;
                    } else {
                        return false;
                    }
                }
            }
        } catch (Exception e) {
            return false;
        }
        return false;
    }

    public boolean validarStrings(String s) {
        if (!s.equals("") && !s.isEmpty()) {
            return true;
        } else {
            return false;
        }
    }

    //Metodo para mostrar mensajes en la pagina
    public void mostrarMensaje(String resumen, String detalle, FacesMessage.Severity severidad) {
        try {
            FacesMessage fm = new FacesMessage(severidad, resumen, detalle);
            FacesContext.getCurrentInstance().addMessage(fm.toString(), fm);
        } catch (Exception e) {
            FacesMessage fm = new FacesMessage(FacesMessage.SEVERITY_ERROR, e.getMessage(), e.getMessage());
            FacesContext.getCurrentInstance().addMessage(fm.toString(), fm);
        }
    }
    // // </editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Combos">
    public SelectItem[] getComboCapitulos() {
        //Combo de Capitulos en la Libertad
        try {
            List<Capitulo> lista = new ArrayList<Capitulo>();
            lista = especialidadCapituloFacade.listarCapitulosLibertad();
            SelectItem[] comboCapitulos = new SelectItem[lista.size()];
            for (int i = 0; i < lista.size(); i++) {
                comboCapitulos[i] = new SelectItem(lista.get(i).getCapCodigo().toString(), lista.get(i).getCapDescripcion());
            }
            return comboCapitulos;
        } catch (Exception e) {
            //Mensaje al usuario
            SelectItem[] comboCapitulos = new SelectItem[1];
            comboCapitulos[0] = new SelectItem("", "No hay Capitulos");
            return comboCapitulos;
        }
    }

    public SelectItem[] getComboAreas() {
        //Combo de Capitulos en la Libertad
        List<Area> lista = new ArrayList<Area>();
        try {
            lista = areaFacade.listarTodos();
            SelectItem[] comboAreas = new SelectItem[lista.size()];
            for (int i = 0; i < lista.size(); i++) {
                comboAreas[i] = new SelectItem(lista.get(i).getAreCodigo().toString(), lista.get(i).getAreNombre());
            }
            return comboAreas;

        } catch (Exception e) {
            //Mensaje al usuario
            SelectItem[] comboAreas = new SelectItem[1];
            comboAreas[0] = new SelectItem("", "No hay Areas");
            return comboAreas;
        }
    }

    public SelectItem[] getComboCursos() {
        try {
            System.out.println("Ingreso 1");
            SelectItem[] selects = null;
            List<PreeventoAdapter> listaCursos = delegate.listarPreEventos_Cursos();
            selects = new SelectItem[listaCursos.size()];
            cont = 0;
            for (PreeventoAdapter preevento : listaCursos) {
                SelectItem item = new SelectItem(preevento.getCodigo(), preevento.getCurso());
                selects[cont++] = item;
            }
            return selects;
        } catch (Exception e) {
            System.out.println("Ingreso Error: " + e.getMessage());
            SelectItem[] selects = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existen cursos");
            selects[0] = item;
            return selects;
        }
    }

    public SelectItem[] getComboPreEvento() {
        try {
            System.out.println("Ingreso 1");
            SelectItem[] selects = null;
            List<Preevento> listaPreEvento = delegate.listarPreeventosActivos();
            selects = new SelectItem[listaPreEvento.size()];
            cont = 0;
            for (Preevento preevento : listaPreEvento) {
                SelectItem item = new SelectItem(preevento.getPreCodigo(), preevento.getPreNombre());
                selects[cont++] = item;
            }
            return selects;
        } catch (Exception e) {
            System.out.println("Ingreso Error: " + e.getMessage());
            SelectItem[] selects = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existen pre-eventos");
            selects[0] = item;
            return selects;
        }
    }

    public PreeventoAdapter buscarPorCodigo(Integer codigo) {
        return delegate.buscarPorCodigo(codigo);
    }

    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Organizador Evento">
    public String agregarCapitulo() {
        OrganizadorEvento org = new OrganizadorEvento();
        Capitulo cap = new Capitulo();
        cap = capituloFacade.find(Integer.parseInt(capituloSeleccionado));
        org.setCapCodigo(cap);
        org.setOrganizador(cap.getCapDescripcion());
        org.setOevTipo(1);
        listaOrganizadores.add(org);
        return "";
    }

    public String agregarArea() {
        OrganizadorEvento org = new OrganizadorEvento();
        Area area = new Area();
        area = areaFacade.buscar(Integer.parseInt(areaSeleccionada));
        org.setAreCodigo(area);
        org.setOrganizador(area.getAreNombre());
        org.setOevTipo(0);
        listaOrganizadores.add(org);
        return "";
    }

    public String agregarOrgExterno() {
        OrganizadorEvento org = new OrganizadorEvento();
        org.setOrganizador(coorganizador);
        org.setOevTipo(2);
        org.setOevCoorganizador(coorganizador);
        listaOrganizadores.add(org);
        return "";
    }

    public String quitarOrganizador() {
        try {
            listaOrganizadores.remove(organizadorEvento);
        } catch (Exception e) {
        }
        return "";
    }

    //*******************************************************
    //CASTOR
    public String registraOrganizador(){
        try{
            for(OrganizadorEvento org : listaOrganizadores) {
                org.setPreCodigo(preEvento);
                delegateOrganizador.registrar(org);
            }
             mostrarMensaje("INFO: ", "Se registro con exito a los organizadores del evento", FacesMessage.SEVERITY_INFO);

          return null;
        }catch(Exception ex){
            mostrarMensaje("ERROR: ", "Al registrar los organizadores del evento", FacesMessage.SEVERITY_ERROR);
            return null;
        }
    }

    public String registrandoInstructor(){

        try {
            //Registrar Instructores
            PersonaNaturalDelegate delegatePersonaN = new PersonaNaturalDelegate();
            for (InstructorEvento ins : listaInstructores) {
                ins.setPreCodigo(preEvento);
                try {
                    if (ins.isRegistrado()) {
                        System.out.println("--If");
                        ins.setPerCodigo(delegatePersonaN.buscarXDNI(ins.getPerCodigo().getPerNroDNI()));
                    } else {
                        System.out.println("--else");
                        delegatePersonaN.registrar(ins.getPerCodigo());
                    }
                } catch (Exception e) {
                    delegatePersonaN.registrar(ins.getPerCodigo());
                }
                ins.setInenroHoras(0); //inicialmente no tiene horas
                ins.setInePrioridad(false); //inicialmente no tiene prioridad
               delegateInstructor.registrar(ins);
            }
             mostrarMensaje("INFO: ", "Se registro con exito a los instructores del evento", FacesMessage.SEVERITY_INFO);
            return null;
        } catch (Exception e) {
            mostrarMensaje("ERROR: ", "Al registrar los instructores del evento", FacesMessage.SEVERITY_ERROR);
            return null;
        }
    }

    public String registrarReserva(){

        try {
            //Registrar la Reserva de Ambientes
            for (CalendarioAmbientesAdapter cal : listaCalendario1) {
                ReservaAmbiente res = new ReservaAmbiente();
                res.setReaEstado("RESERVADO");
                if (cal.getTipo() == 0) {
                    res.setAmbCodigo(cal.getAmbiente());
                } else {
                    res.setSerCodigo(cal.getServicio());
                }
                res.setEveCodigo(preEvento);
//              res.setReaFecha(fechaAmbiente);   //corregido por lizardo
                res.setReaFecha(cal.getFecha());    //corregido por lizardo
                res.setReaTipoae(cal.getTipo());
                res.setReaTipoec(0);
                res.setReahoraInicio(cal.getHoraInicio());
                res.setReahoraFin(cal.getHoraFin());
                delegateReserva.registrar(res);
            }
            mostrarMensaje("INFO: ", "Se registro con exito a la reserva del evento", FacesMessage.SEVERITY_INFO);
            return null;
        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "Al registrar la reserva del evento", FacesMessage.SEVERITY_ERROR);
            return null;
        }
    }



    //FIN CASTOR

    public String modificarOrganizador() {
        try {
            listaOrganizadores1.clear();
            listaOrganizadores = new ArrayList<OrganizadorEvento>();
            listaOrganizadores = delegateOrganizador.listarPorEvento(preEventoSeleccionado);
            listaOrganizadores1 = listaOrganizadores;
        } catch (Exception e) {
        }
        return "organizador";
    }

    public String actualizarOrganizadorDEL() {
        try {
            delegateOrganizador.eliminarOrganizadores(listaOrganizadores1);
            
            for (OrganizadorEvento org : listaOrganizadores) {
                org.setPreCodigo(preEventoSeleccionado);
                delegateOrganizador.registrar(org);
            }
            mostrarMensaje("INFO: ", "Se actualizo con exito a los organizadores del evento", FacesMessage.SEVERITY_INFO);
        } catch (Exception e) {
            mostrarMensaje("ERROR: ", "En actualizar los organizadores del evento", FacesMessage.SEVERITY_ERROR);
            System.out.println("FATAL: " + e.getMessage());
        }
        return null;
    }

    public String actualizarOrganizador() {
        try {
            for (OrganizadorEvento org : listaOrganizadores) {
                Integer oevCodigo = org.getOevCodigo();
                Integer preCodigo = preEventoSeleccionado.getPreCodigo();
                if (!delegateOrganizador.estaRegistrado(oevCodigo, preCodigo)) {
                    org.setPreCodigo(preEventoSeleccionado);
                    delegateOrganizador.registrar(org);
                }
            }
            mostrarMensaje("INFO: ", "Se actualizo con exito a los organizadores del evento", FacesMessage.SEVERITY_INFO);
        } catch (Exception e) {
            mostrarMensaje("ERROR: ", "En actualizar los organizadores del evento", FacesMessage.SEVERITY_ERROR);
            System.out.println("FATAL: " + e.getMessage());
        }
        return null;
    }

    public String cancelarOrganizador() {
        listaOrganizadores1.clear();
        listaOrganizadores.clear();
//        preEventoSeleccionado=new Preevento();
        return "ir_preevento";
    }

    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Ambientes Evento">
    public String listarAmbientesEstado() {
        try {
//            Calendar c = Calendar.getInstance();
//            c.setTime(new Date());
//            c.add(Calendar.DAY_OF_MONTH, 6);
//            int result = c.getTime().compareTo(fechaAmbiente);
//            System.out.println("result: " + result);
//            if (result <= 0) {
                List<ReservaAmbiente> listaReservas = new ArrayList<ReservaAmbiente>();
                listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
                listaReservas = delegateReserva.listarReserva_Dia(fechaAmbiente, ambiente);
                //Cargar Ambientes
                for (int i = 7; i < 24; i++) {
                    int j;
                    boolean var = true;
                    j = i + 1;
                    for (ReservaAmbiente res : listaReservas) {
                        if (res.getReahoraInicio() == i) {
                            var = false;
                        }
                    }
                    if (var) {
                        CalendarioAmbientesAdapter adap = new CalendarioAmbientesAdapter();
                        adap.setHoraInicio(new Double(i));
                        adap.setHoraFin(new Double(j));
                        adap.setHorario(i + ".00  - " + i + ".50");
                        adap.setEstado("RESERVAR");
                        adap.setHabilitado(true);
                        adap.setTipo(0);
                        adap.setAmbiente(ambiente);
                        adap.setNombre(ambiente.getAmbNombre());
                        listaCalendario.add(adap);
                    }
                }
//            }
//            else {
//                listaCalendario.clear();
//                SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
//                c.add(Calendar.DAY_OF_MONTH, 1);
//                String fecha = sdf.format(c.getTime());
//                mostrarMensaje("Error: ", "Los Ambientes se reservan con una semana antes de anticipacion  de la fecha Actual, ejemplo: " + fecha, FacesMessage.SEVERITY_ERROR);
//            }
        } catch (Exception e) {
            mostrarMensaje("Error: ", e.getMessage(), FacesMessage.SEVERITY_ERROR);
        }
        return "";
    }

    public String listarAmbientesEstado1() {
//        Calendar c = Calendar.getInstance();
//        c.setTime(new Date());
//        c.add(Calendar.DAY_OF_MONTH, 1);
//        if (c.getTime().compareTo(fechaAmbiente) <= 0) {
            try {
                List<ReservaAmbiente> listaReservas = new ArrayList<ReservaAmbiente>();
                listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
                listaReservas = delegateReserva.listarReserva_Dia(fechaAmbiente, ambiente);
                //Cargar Ambientes
                for (int i = 7; i < 24; i++) {
                    int j;
                    boolean var = true;
                    j = i + 1;
                    for (ReservaAmbiente res : listaReservas) {
                        if (res.getReahoraInicio() == i) {
                            var = false;
                        }
                    }
                    if (var) {
                        CalendarioAmbientesAdapter adap = new CalendarioAmbientesAdapter();
                        adap.setHoraInicio(new Double(i));
                        adap.setHoraFin(new Double(j));
                        adap.setHorario(i + ".00  - " + i + ".50");
                        adap.setEstado("RESERVAR");
                        adap.setHabilitado(true);
                        adap.setTipo(0);
                        adap.setAmbiente(ambiente);
                        adap.setNombre(ambiente.getAmbNombre());
                        listaCalendario.add(adap);
                    }
                }
            } catch (Exception e) {
                System.out.println("Errorrr " + e.toString());
            }
            return "";
//        } else {
//            listaCalendario.clear();
//            mostrarMensaje("Error", "Los Ambientes se reservan un dia antes de la fecha de colegiación", FacesMessage.SEVERITY_ERROR);
//            return "";
//        }
    }

    public String listarServiciosEstado1() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        c.add(Calendar.DAY_OF_MONTH, 1);
        if (c.getTime().compareTo(fechaAmbiente) <= 0) {
            try {
                List<ReservaAmbiente> listaReservas = new ArrayList<ReservaAmbiente>();
                listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
                listaReservas = delegateReserva.listarReserva_Dia(fechaAmbiente, equipo);
                //Cargar Ambientes
                for (int i = 7; i < 24; i++) {
                    int j;
                    boolean var = true;
                    j = i + 1;
                    for (ReservaAmbiente res : listaReservas) {
                        if (res.getReahoraInicio() == i) {
                            var = false;
                        }
                    }
                    if (var) {
                        CalendarioAmbientesAdapter adap = new CalendarioAmbientesAdapter();
                        adap.setHoraInicio(new Double(i));
                        adap.setHoraFin(new Double(j));
                        adap.setHorario(i + ".00  - " + i + ".50");
                        adap.setEstado("RESERVAR");
                        adap.setHabilitado(true);
                        adap.setTipo(1);
                        adap.setServicio(equipo);
                        adap.setNombre(equipo.getSerNombre());
                        listaCalendario.add(adap);
                    }

                }
            } catch (Exception e) {
                System.out.println("Errorrr " + e.toString());
            }
        } else {
            mostrarMensaje("Error", "Los Ambientes se reservan un dia antes de la fecha de colegiación", FacesMessage.SEVERITY_ERROR);
        }

        return "";
    }

    public String listarServiciosEstado() {
        Calendar c = Calendar.getInstance();
        c.setTime(new Date());
        c.add(Calendar.DAY_OF_MONTH, 6);
        if (c.getTime().compareTo(fechaAmbiente) <= 0) {
            try {
                List<ReservaAmbiente> listaReservas = new ArrayList<ReservaAmbiente>();
                listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
                listaReservas = delegateReserva.listarReserva_Dia(fechaAmbiente, equipo);
                //Cargar Ambientes
                for (int i = 7; i < 24; i++) {
                    int j;
                    boolean var = true;
                    j = i + 1;
                    for (ReservaAmbiente res : listaReservas) {
                        if (res.getReahoraInicio() == i) {
                            var = false;
                        }
                    }
                    if (var) {
                        CalendarioAmbientesAdapter adap = new CalendarioAmbientesAdapter();
                        adap.setHoraInicio(new Double(i));
                        adap.setHoraFin(new Double(j));
                        adap.setHorario(i + ".00  - " + i + ".50");
                        adap.setEstado("RESERVAR");
                        adap.setHabilitado(true);
                        adap.setTipo(1);
                        adap.setServicio(equipo);
                        adap.setNombre(equipo.getSerNombre());
                        listaCalendario.add(adap);
                    }

                }
            } catch (Exception e) {
                System.out.println("Errorrr " + e.toString());
            }
        } else {
            listaCalendario.clear();
            SimpleDateFormat sdf = new SimpleDateFormat("dd/MM/yyyy");
            c.add(Calendar.DAY_OF_MONTH, 1);
            String fecha = sdf.format(c.getTime());
            mostrarMensaje("Error: ", "Los Ambientes se reservan con una semana antes de anticipacion  de la fecha Actual, ejemplo: " + fecha, FacesMessage.SEVERITY_ERROR);
        }

        return "";
    }

    public String agregarAmbSeleccionados() {
        for (CalendarioAmbientesAdapter cal : listaCalendario) {
            if (cal.getReservar()) {
                cal.setFecha(fechaAmbiente);
                listaCalendario1.add(cal);
            }
        }
        for (CalendarioAmbientesAdapter cal : listaCalendario1) {
            listaCalendario.remove(cal);
        }

        return "";
    }

    public String quitarAmbSeleccionados() {
        try {
            listaCalendario.add(ambienteSeleccionado);
            listaCalendario1.remove(ambienteSeleccionado);
        } catch (Exception e) {
            mostrarMensaje("ERROR: ", "En quitar ambiente seleccionado", FacesMessage.SEVERITY_ERROR);
            System.out.println("FATAL: " + e.getMessage());
        }
        return "";
    }

    public String modificarReservaAmbiente() {
        listaCalendario = new ArrayList<CalendarioAmbientesAdapter>();
        listaCalendario1 = new ArrayList<CalendarioAmbientesAdapter>();
        List<ReservaAmbiente> listaReservas = new ArrayList<ReservaAmbiente>();
        try {
            listaReservas = delegateReserva.listarReservaPorEvento(preEventoSeleccionado);
            for (ReservaAmbiente res : listaReservas) {
                CalendarioAmbientesAdapter cal = new CalendarioAmbientesAdapter();
                if (res.getReaTipoae() == 0) {
                    cal.setTipo(0);
                    cal.setAmbiente(res.getAmbCodigo());
                    cal.setNombre(res.getAmbCodigo().getAmbNombre());
                } else {
                    cal.setTipo(1);
                    cal.setServicio(res.getSerCodigo());
                    cal.setNombre(res.getSerCodigo().getSerNombre());
                }
                cal.setFecha(res.getReaFecha());
                cal.setHoraInicio(res.getReahoraInicio());
                cal.setHoraFin(res.getReahoraFin());
                cal.setHorario(res.getReahoraInicio() + "0 - " + res.getReahoraFin() + "0");
                listaCalendario1.add(cal);
            }
        } catch (Exception e) {
        }
        return "reserva";
    }

    public String modificarReservas() {
        try {
            if (listaCalendario1.size() > 0) {
                List<ReservaAmbiente> listaReservas = new ArrayList<ReservaAmbiente>();
                listaReservas = delegateReserva.listarReservaPorEvento(preEventoSeleccionado);
                for (ReservaAmbiente res : listaReservas) {
                    delegateReserva.eliminar(res);
                }
                for (CalendarioAmbientesAdapter cal : listaCalendario1) {
                    ReservaAmbiente res = new ReservaAmbiente();
                    res.setReaEstado("RESERVADO");
                    if (cal.getTipo() == 0) {
//                        res.setAmbCodigo(ambiente);           //corregido por lizardo
                        res.setAmbCodigo(cal.getAmbiente());    //corregido por lizardo
                    } else {
//                        res.setSerCodigo(equipo);             //corregido por lizardo
                        res.setSerCodigo(cal.getServicio());    //corregido por lizardo
                    }
                    res.setEveCodigo(preEventoSeleccionado);
//                    res.setReaFecha(fechaAmbiente); //corregido por lizardo
                    res.setReaFecha(cal.getFecha()); //corregido por lizardo
                    res.setReaTipoae(cal.getTipo());
                    res.setReaTipoec(0);
                    res.setReahoraInicio(cal.getHoraInicio());
                    res.setReahoraFin(cal.getHoraFin());
                    delegateReserva.registrar(res);
                }
                mostrarMensaje("Exito", "Se postergo correctamente el Evento", FacesMessage.SEVERITY_INFO);
                inicializar();
            } else {
                mostrarMensaje("Error", "Seleccione por lo menos un ambiente", FacesMessage.SEVERITY_ERROR);
            }
        } catch (Exception e) {
        }
        return null;
    }

    public String cancelarPostergacion() {
//        inicializar();
        return "regresar";
    }

    public String cancelarModifiReserva() {
//        inicializar();
        return "regresar2";
    }

    public String navegarPostergar() {
        modificarReservaAmbiente();
        return "detalle";
    }

    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Presupuesto Evento">
    public String registrarTipoIngreso() {
        try {
            delegateTIngresos.guardar(tipoIngreso);
            cargarTipoPartIng();
            tipoIngreso = new TipoIngresoEventos();
//            HtmlModalPanel myPanel = new HtmlModalPanel();
//            myPanel.set
            //listaIngresos = delegateTIngresos.listar_Todos();
        } catch (Exception e) {
        }
        return null;
    }

    public String cargarEventosPresupuesto() {
        try {
            listaPreEventosPresupuesto = delegate.listarPermitosModificarPresupuesto();
        } catch (Exception e) {
        }
        return "";
    }

    public void listarModeloPresupuesto() {
        //Para las promociones
        listaDetalleConcepto = new ArrayList<DetalleConcepto>();
        try {
            listaDetalleConcepto = delegateDetConcepto.listarDetalleConcepto();
        } catch (Exception ex) {
            Logger.getLogger(PreEventoController.class.getName()).log(Level.SEVERE, null, ex);
        }
    }

    public String agregarESeleccionados() {
        try {
            for (DetalleConcepto con : listaDetalleConcepto) {
                if (con.getSeleccionado()) {
                    con.setSeleccionado(false);
                    con.setNroOrden(cont);
                    cont++;
                    listadetalleEgresos.add(con);
                }
            }
            for (DetalleConcepto con : listadetalleEgresos) {
                listaDetalleConcepto.remove(con);
            }
        } catch (Exception e) {
        }
        return "";
    }

    public String agregarETodos() {
        try {
            for (DetalleConcepto con : listaDetalleConcepto) {
                con.setSeleccionado(false);
                con.setNroOrden(cont);
                cont++;
                listadetalleEgresos.add(con);
            }
            listaDetalleConcepto.clear();
        } catch (Exception e) {
        }
        return "";
    }

    public String quitarETodos() {
        try {
            listadetalleEgresos.clear();
            listaDetalleConcepto.clear();
            listaDetalleConcepto = delegateDetConcepto.listarDetalleConcepto();
        } catch (Exception e) {
        }
        return null;
    }

    public String quitarESeleccionados() {
        try {
            for (DetalleConcepto con : listadetalleEgresos) {
                if (con.getSeleccionado()) {
                    con.setSeleccionado(false);
                    listaDetalleConcepto.add(con);
                }
            }
            for (DetalleConcepto con1 : listaDetalleConcepto) {
                listadetalleEgresos.remove(con1);
            }
        } catch (Exception e) {
        }
        return null;
    }

    public String calcularEgresos() {
        try {
            egresos = 0.0;
            for (DetalleConcepto con : listadetalleEgresos) {
                egresos = egresos + con.getMonto1();
                if (con.getBand2()) {
                    egresos = egresos + con.getMonto2();
                }
                if (con.getBand3()) {
                    egresos = egresos + con.getMonto3();
                }
                if (con.getBand4()) {
                    egresos = egresos + con.getMonto4();
                }
                if (con.getBand5()) {
                    egresos = egresos + con.getMonto5();
                }
                if (con.getBand6()) {
                    egresos = egresos + con.getMonto6();
                }
                if (con.getBand7()) {
                    egresos = egresos + con.getMonto7();
                }
                if (con.getBand8()) {
                    egresos = egresos + con.getMonto8();
                }
                if (con.getBand9()) {
                    egresos = egresos + con.getMonto9();
                }
                if (con.getBand10()) {
                    egresos = egresos + con.getMonto10();
                }
                if (con.getBand11()) {
                    egresos = egresos + con.getMonto11();
                }
                if (con.getBand12()) {
                    egresos = egresos + con.getMonto12();
                }
                if (con.getBand13()) {
                    egresos = egresos + con.getMonto13();
                }
                if (con.getBand14()) {
                    egresos = egresos + con.getMonto14();
                }
                if (con.getBand15()) {
                    egresos = egresos + con.getMonto15();
                }
                if (con.getBand16()) {
                    egresos = egresos + con.getMonto16();
                }
                if (con.getBand17()) {
                    egresos = egresos + con.getMonto17();
                }
                if (con.getBand18()) {
                    egresos = egresos + con.getMonto18();
                }
                if (con.getBand19()) {
                    egresos = egresos + con.getMonto19();
                }
                if (con.getBand20()) {
                    egresos = egresos + con.getMonto20();
                }
                if (con.getBand21()) {
                    egresos = egresos + con.getMonto21();
                }
                if (con.getBand22()) {
                    egresos = egresos + con.getMonto22();
                }
                if (con.getBand23()) {
                    egresos = egresos + con.getMonto23();
                }
                if (con.getBand24()) {
                    egresos = egresos + con.getMonto24();
                }

            }
        } catch (Exception e) {
        }
        
        utilidad = ingresos - egresos;
        return "";
    }

    public String agregarRangos() {
        try {
            if (fechaR1Inicio.equals(null)) {
                mostrarMensaje("Error", "Ingrese Fecha Inicio correctamente", FacesMessage.SEVERITY_ERROR);
                return null;
            }
        } catch (Exception e) {
            mostrarMensaje("Error", "Ingrese Fecha Inicio correctamente", FacesMessage.SEVERITY_ERROR);
            return null;
        }
        try {
            if (fechaR1Fin.equals(null)) {
                mostrarMensaje("Error", "Ingrese Fecha Fin correctamente", FacesMessage.SEVERITY_ERROR);
                return null;
            }
        } catch (Exception e) {
            mostrarMensaje("Error", "Ingrese Fecha Fin correctamente", FacesMessage.SEVERITY_ERROR);
            return null;
        }
        try {
            if (fechaR1Fin.compareTo(fechaR1Inicio) >= 0) {
                boolean varr = true;
                for (RangoMatriculas rang : listaRangos) {
                    //Si la fecha Fin del Rango ANterior es menor q la nueva fecha incial del rango
                    //entonces no agrego varr=false
                    if (rang.getFechaFin().compareTo(fechaR1Inicio) < 0) {
                        varr = false;
                    }
                }
                if (varr) {
                    RangoMatriculas rmat = new RangoMatriculas();
                    rmat.setFechaIni(fechaR1Inicio);
                    rmat.setFechaFin(fechaR1Fin);
                    rmat.setInd(listaRangos.size() + 1);
                    listaRangos.add(rmat);
                    fechaR1Inicio = fechaR1Fin = null;
                } else {
                    mostrarMensaje("Error", "El nuevo rango debe comenzar despues al anterior", FacesMessage.SEVERITY_ERROR);
                    return null;
                }
            } else {
                mostrarMensaje("Error", "La fecha Inicial del Rango no puede mayor ser a la fecha Final del Rango", FacesMessage.SEVERITY_ERROR);
                return null;
            }
        } catch (Exception e) {
            System.out.println("Error add en----------- " + e.toString());
        }
        return "";
    }

    public String calcularIngresos() {
        ingresos = 0.0;
        try {
            for (DetIngresosAdapter det : listaIngresosAdapter) {
                for (EstimacionParticipantes est : listaEstimacionParticipantes) {
                    if (est.getRang().equals(det.getRang())) {
                        for (TipoIngresoEventos tip : listaIngresos2) {
                            if (!est.getM1() && det.getTipoIngreso().equals(tip)) {
                                ingresos = ingresos + det.getMont1() * est.getCant1() * tip.getNumCuotas();
                            }
                            if (!est.getM2() && det.getTipoIngreso().equals(tip)) {
                                ingresos = ingresos + det.getMont2() * est.getCant2() * tip.getNumCuotas();
                            }

                            if (!est.getM3() && det.getTipoIngreso().equals(tip)) {
                                ingresos = ingresos + det.getMont3() * est.getCant3() * tip.getNumCuotas();
                            }

                            if (!est.getM4() && det.getTipoIngreso().equals(tip)) {
                                ingresos = ingresos + det.getMont4() * est.getCant4() * tip.getNumCuotas();
                            }

                            if (!est.getM5() && det.getTipoIngreso().equals(tip)) {
                                ingresos = ingresos + det.getMont5() * est.getCant5() * tip.getNumCuotas();
                            }

                            if (!est.getM6() && det.getTipoIngreso().equals(tip)) {
                                ingresos = ingresos + det.getMont6() * est.getCant6() * tip.getNumCuotas();
                            }

                        }
                    }
                }
            }
        } catch (Exception e) {
            mostrarMensaje("Error:", "Ingrese los Datos Correctamente.", FacesMessage.SEVERITY_ERROR);
            System.out.print("El error es... " + e.toString());
        }
        utilidad = ingresos - egresos;
        return "";
    }

    public TipoParticipanteEvento findTParticipante(int id) {
        try {
            return delegateTipoParticipante.buscar(id);
        } catch (Exception e) {
            return new TipoParticipanteEvento();
        }
    }

    public void modifPresupuesto() {
        try {
            //Llenar los Ingresos
            listaDetalleIngresos.clear();
            listaDetalleIngresos = delegateDetIngresos.listarPorEvento(preEventoSeleccionado);
            //Limpiar las Listas
            listaIngresos1.clear();
            listaIngresos2.clear();
            listaEstimacionParticipantes.clear();
            listaRangos.clear();
            listaTParticipantes1.clear();
            boolean varp = true;
            //Agregamos los Rangos
            listaRangos = delegateDetIngresos.listarRangos(preEventoSeleccionado);
            //Agregar los Tipos de Ingresos
            for (DetalleIngresosEventos det : listaDetalleIngresos) {
                if (varp) {
                    listaIngresos1.add(det.getTpiCodigo());
                    varp = false;
                } else {
                    if (!listaIngresos1.contains(det.getTpiCodigo())) {
                        listaIngresos1.add(det.getTpiCodigo());
                    }
                }
            }
            //Insertamos los Tipos de Participantes
            varp = true;
            for (DetalleIngresosEventos det : listaDetalleIngresos) {
                if (varp) {
                    listaTParticipantes1.add(det.getTpeCodigo());
                    varp = false;
                } else {
                    if (!listaTParticipantes1.contains(det.getTpeCodigo())) {
                        listaTParticipantes1.add(det.getTpeCodigo());
                    }
                }
            }
            //Agregar a los Adapters
            agregarIngresos();
//            calcularIngresos();
            //Recuperar los Montos
            for (int i = 0; i < listaIngresosAdapter.size(); i++) {
                if (!listaIngresosAdapter.get(i).getM1()) {
                    Double mont = 0.0;
                    Integer tipo1 = listaIngresosAdapter.get(i).getTip1().getTpeCodigo();
                    Integer tipo2 = listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo();
                    Date fecha = listaIngresosAdapter.get(i).getRang().getFechaIni();
                    Integer preevento = preEventoSeleccionado.getPreCodigo();
                    try {
                        mont = delegateDetIngresos.retornarUltimoMonto(tipo1, tipo2, fecha, preevento);
                    } catch (Exception ex) {
                        mostrarMensaje("WARN: ", "Consulte con su administrador, no se pudo recuperar el monto", FacesMessage.SEVERITY_WARN);
                        System.out.println("FATAL: " + ex.getMessage());
                    }
                    //mont = delegateDetIngresos.retornarMonto(tipo1, tipo2, fecha, preevento);
                    listaIngresosAdapter.get(i).setMont1(mont);
                }
                if (!listaIngresosAdapter.get(i).getM2()) {
                    Double mont = 0.0;
                    Integer tipo1 = listaIngresosAdapter.get(i).getTip2().getTpeCodigo();
                    Integer tipo2 = listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo();
                    Date fecha = listaIngresosAdapter.get(i).getRang().getFechaIni();
                    Integer preevento = preEventoSeleccionado.getPreCodigo();
                    mont = delegateDetIngresos.retornarUltimoMonto(tipo1, tipo2, fecha, preevento);
                    //mont = delegateDetIngresos.retornarMonto(tipo1, tipo2, fecha, preevento);
                    listaIngresosAdapter.get(i).setMont2(mont);
                }
                if (!listaIngresosAdapter.get(i).getM3()) {
                    Double mont = 0.0;
                    mont = delegateDetIngresos.retornarUltimoMonto(listaIngresosAdapter.get(i).getTip3().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    //mont = delegateDetIngresos.retornarMonto(listaIngresosAdapter.get(i).getTip3().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    listaIngresosAdapter.get(i).setMont3(mont);
                }
                if (!listaIngresosAdapter.get(i).getM4()) {
                    Double mont = 0.0;
                    mont = delegateDetIngresos.retornarUltimoMonto(listaIngresosAdapter.get(i).getTip4().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    //mont = delegateDetIngresos.retornarMonto(listaIngresosAdapter.get(i).getTip4().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    listaIngresosAdapter.get(i).setMont4(mont);
                }
                if (!listaIngresosAdapter.get(i).getM5()) {
                    Double mont = 0.0;
                    mont = delegateDetIngresos.retornarUltimoMonto(listaIngresosAdapter.get(i).getTip5().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    //mont = delegateDetIngresos.retornarMonto(listaIngresosAdapter.get(i).getTip5().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    listaIngresosAdapter.get(i).setMont5(mont);
                }
                if (!listaIngresosAdapter.get(i).getM6()) {
                    Double mont = 0.0;
                    mont = delegateDetIngresos.retornarUltimoMonto(listaIngresosAdapter.get(i).getTip6().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    //mont = delegateDetIngresos.retornarMonto(listaIngresosAdapter.get(i).getTip6().getTpeCodigo(), listaIngresosAdapter.get(i).getTipoIngreso().getTpiCodigo(), listaIngresosAdapter.get(i).getRang().getFechaIni(), preEventoSeleccionado.getPreCodigo());
                    listaIngresosAdapter.get(i).setMont6(mont);
                }
            }
            //quitar los elementos de la lista ya agregada se le quita a la lista base
            //TipoParticipantes
            for (TipoParticipanteEvento tip : listaTParticipantes1) {
                listaTParticipantes.remove(tip);
            }
            //Tipo Ingresos
            for (TipoIngresoEventos tip : listaIngresos1) {
                listaIngresos.remove(tip);
            }
            //LLenar Los Egresos           
            listadetalleEgresos = new ArrayList<DetalleConcepto>();
            try {
                listaPresupuestos = new ArrayList<ModeloPresupuesto>();
                listaPresupuestos = delegatePresupuesto.listarPorEvento(preEventoSeleccionado);
                System.out.println("Numero de Presupuestos " + listaPresupuestos.size());
                for (ModeloPresupuesto model : listaPresupuestos) {
                    try {
                        listaEgresos = new ArrayList<DetalleEgresos>();
                        listaEgresos = delegateDetEgresos.listarPorPresupuesto(model);
                        System.out.println("Numero de Egresos " + listaEgresos.size());
                    } catch (Exception e) {
                    }
                    switch (model.getPcuNroModulos()) {
                        case 1:
                            for (DetalleEgresos det : listaEgresos) {
                                DetalleConcepto con = new DetalleConcepto();
                                con = det.getDcoCodigo();
                                con.setMonto1(det.getDprMonto());
                                listadetalleEgresos.add(con);
                            }
                            break;
                        case 2:
                            int i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto2(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand2(true);
                                i++;
                            }
                            break;
                        case 3:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto3(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand3(true);
                                i++;
                            }
                            break;
                        case 4:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto4(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand4(true);
                                i++;
                            }
                            break;
                        case 5:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto5(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand5(true);
                                i++;
                            }
                            break;
                        case 6:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto6(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand6(true);
                                i++;
                            }
                            break;
                        case 7:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto7(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand7(true);
                                i++;
                            }
                            break;
                        case 8:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto8(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand8(true);
                                i++;
                            }
                            break;
                        case 9:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto9(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand9(true);
                                i++;
                            }
                            break;
                        case 10:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto10(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand10(true);
                                i++;
                            }
                            break;
                        case 11:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto11(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand11(true);
                                i++;
                            }
                            break;
                        case 12:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto12(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand12(true);
                                i++;
                            }
                            break;
                        case 13:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto13(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand13(true);
                                i++;
                            }
                            break;
                        case 14:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto14(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand14(true);
                                i++;
                            }
                            break;
                        case 15:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto15(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand15(true);
                                i++;
                            }
                            break;
                        case 16:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto16(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand16(true);
                                i++;
                            }
                            break;
                        case 17:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto17(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand17(true);
                                i++;
                            }
                            break;
                        case 18:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto18(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand18(true);
                                i++;
                            }
                            break;
                        case 19:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto19(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand19(true);
                                i++;
                            }
                            break;
                        case 20:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto20(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand20(true);
                                i++;
                            }
                            break;
                        case 21:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto21(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand21(true);
                                i++;
                            }
                            break;
                        case 22:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto22(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand22(true);
                                i++;
                            }
                            break;
                        case 23:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto23(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand23(true);
                                i++;
                            }
                            break;
                        case 24:
                            i = 0;
                            for (DetalleEgresos det : listaEgresos) {
                                listadetalleEgresos.get(i).setMonto24(det.getDprMonto());
                                listadetalleEgresos.get(i).setBand24(true);
                                i++;
                            }
                            break;
                    }

                }
                //quitar los Egresos
                for (DetalleConcepto det : listadetalleEgresos) {
                    listaDetalleConcepto.remove(det);
                }
                //Setear los valores de las estimaciones
                for (int i = 0; i < listaEstimacionParticipantes.size(); i++) {
                    if (!listaEstimacionParticipantes.get(i).getM1()) {
                        Integer cant = 0;
                        Date fecha = listaEstimacionParticipantes.get(i).getRang().getFechaIni();
                        Integer tipo = listaEstimacionParticipantes.get(i).getTip1().getTpeCodigo();
                        Integer preevento = preEventoSeleccionado.getPreCodigo();
                        cant = delegateEstimacion.retornarUltimaCantidad(fecha, tipo, preevento);
                        //cant = delegateEstimacion.retornarCantidad(fecha, tipo, preevento);
                        listaEstimacionParticipantes.get(i).setCant1(cant);
                    }
                    if (!listaEstimacionParticipantes.get(i).getM2()) {
                        Integer cant = 0;
                        Date fecha = listaEstimacionParticipantes.get(i).getRang().getFechaIni();
                        Integer tipo = listaEstimacionParticipantes.get(i).getTip2().getTpeCodigo();
                        Integer preevento = preEventoSeleccionado.getPreCodigo();
                        cant = delegateEstimacion.retornarUltimaCantidad(fecha, tipo, preevento);
                        //cant = delegateEstimacion.retornarCantidad(fecha, tipo, preevento);
                        listaEstimacionParticipantes.get(i).setCant2(cant);
                    }
                    if (!listaEstimacionParticipantes.get(i).getM3()) {
                        Integer cant = 0;
                        cant = delegateEstimacion.retornarUltimaCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip3().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        //cant = delegateEstimacion.retornarCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip3().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        listaEstimacionParticipantes.get(i).setCant3(cant);
                    }
                    if (!listaEstimacionParticipantes.get(i).getM4()) {
                        Integer cant = 0;
                        cant = delegateEstimacion.retornarUltimaCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip4().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        //cant = delegateEstimacion.retornarCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip4().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        listaEstimacionParticipantes.get(i).setCant4(cant);
                    }
                    if (!listaEstimacionParticipantes.get(i).getM5()) {
                        Integer cant = 0;
                        cant = delegateEstimacion.retornarUltimaCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip5().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        //cant = delegateEstimacion.retornarCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip5().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        listaEstimacionParticipantes.get(i).setCant5(cant);
                    }
                    if (!listaEstimacionParticipantes.get(i).getM6()) {
                        Integer cant = 0;
                        cant = delegateEstimacion.retornarUltimaCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip6().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        //cant = delegateEstimacion.retornarCantidad(listaEstimacionParticipantes.get(i).getRang().getFechaIni(), listaEstimacionParticipantes.get(i).getTip6().getTpeCodigo(), preEventoSeleccionado.getPreCodigo());
                        listaEstimacionParticipantes.get(i).setCant6(cant);
                    }
                }
                //Setear el Numero de Cuotas
                for (int i = 0; i < listaIngresos2.size(); i++) {
                    Integer nro = 0;
                    nro = delegateDetIngresos.retornarNroCuotas(listaIngresos2.get(i).getTpiCodigo(), preEventoSeleccionado.getPreCodigo());
                    listaIngresos2.get(i).setNumCuotas(nro);
                }
            } catch (Exception e) {
            }
            ingresos = preEventoSeleccionado.getPreIngresos();
            egresos = preEventoSeleccionado.getPreEgresos();
            utilidad = preEventoSeleccionado.getPreUtilidad();
        } catch (Exception e) {
        }
    }

    public String modificarPresupuesto() {
        //Recuperar los Datos del Presupuesto a Modificar
        //LLenado de la Primera Matriz
//        if (preEventoSeleccionado.getPreEstado().equals("INICIADO") || preEventoSeleccionado.getPreEstado().equals("PRESUPUESTO DESAPROBADO") || preEventoSeleccionado.getPreEstado().equals("DESAPROBADO")) {
        modifPresupuesto();
//        mostrarMensaje("Error", "Solo se puede modificar el Presupuesto cuando esta iniciado o es desaprobado", FacesMessage.SEVERITY_ERROR);
//        }
        return "presupuesto";
    }

    public String actualizarPresupuesto() {
        try {
            //Actualizar Ing,Egre,Uti
            calcularIngresos();
            calcularEgresos();
            
            if (utilidad > 0) {
                preEventoSeleccionado.setPreEgresos(egresos);
                preEventoSeleccionado.setPreIngresos(ingresos);
                preEventoSeleccionado.setPreUtilidad(utilidad);
                delegate.actualizar(preEventoSeleccionado);
                //Actualizar Matriz de Ingresos(DetalleIngresos)              
                delegateDetIngresos.eliminarPorEvento(preEventoSeleccionado);
                delegateEstimacion.eliminarPorEvento(preEventoSeleccionado);
                registrarIngresosEst(preEventoSeleccionado);
                //Actualizar Egresos
                eliminarEgresos();
                registrarPresupuesto(preEventoSeleccionado);
                mostrarMensaje("Exito", "Los cambios se guardaron correctamente.", FacesMessage.SEVERITY_INFO);
                inicializar();
                return "retornarpre";
            } else {
                mostrarMensaje("Error", "La uilidad debe ser mayor a cero", FacesMessage.SEVERITY_ERROR);
                return "retornarpre";
            }
        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
        }
        return "";
    }

    public String eliminarEgresos() {
        //Eliminar los Detalles de Egresos
        for (DetalleEgresos det : listaEgresos) {
            try {
                delegateDetEgresos.eliminar(det);
            } catch (Exception e) {
            }
        }
        //Eliminar Modelo de Presupuesto
        for (ModeloPresupuesto mod : listaPresupuestos) {
            try {
                delegatePresupuesto.eliminar(mod);
            } catch (Exception e) {
            }
        }
        return "";
    }

    public void registrarPresupuesto(Preevento pre) {
        //Registrar Presupuestos
        for (int i = 1; i <= pre.getNroMesesPresupuesto(); i++) {
            ModeloPresupuesto modeloPresp = new ModeloPresupuesto();
            modeloPresp.setPcufechaCreacion(new Date());
            modeloPresp.setPcufechaActualizacion(new Date());
            modeloPresp.setPreevento(pre);
            modeloPresp.setPcuEstado(true);
            if (i == 1) {
                modeloPresp.setPcuNroModulos(1);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto1());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    detalle.setDprEstado(true);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 2) {
                modeloPresp.setPcuNroModulos(2);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto2());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 3) {
                modeloPresp.setPcuNroModulos(3);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto3());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 4) {
                modeloPresp.setPcuNroModulos(4);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto4());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 5) {
                modeloPresp.setPcuNroModulos(5);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto5());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 6) {
                modeloPresp.setPcuNroModulos(6);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto6());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 7) {
                modeloPresp.setPcuNroModulos(7);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto7());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 8) {
                modeloPresp.setPcuNroModulos(8);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto8());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 9) {
                modeloPresp.setPcuNroModulos(9);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto9());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 10) {
                modeloPresp.setPcuNroModulos(10);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto10());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 11) {
                modeloPresp.setPcuNroModulos(11);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto11());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 12) {
                modeloPresp.setPcuNroModulos(12);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto12());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 13) {
                modeloPresp.setPcuNroModulos(13);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto13());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 14) {
                modeloPresp.setPcuNroModulos(14);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto14());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 15) {
                modeloPresp.setPcuNroModulos(15);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto15());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 16) {
                modeloPresp.setPcuNroModulos(16);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto16());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 17) {
                modeloPresp.setPcuNroModulos(17);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto17());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 18) {
                modeloPresp.setPcuNroModulos(18);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto18());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 19) {
                modeloPresp.setPcuNroModulos(19);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto19());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 20) {
                modeloPresp.setPcuNroModulos(20);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto20());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 21) {
                modeloPresp.setPcuNroModulos(21);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto21());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 22) {
                modeloPresp.setPcuNroModulos(22);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto22());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 23) {
                modeloPresp.setPcuNroModulos(23);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto23());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
            if (i == 24) {
                modeloPresp.setPcuNroModulos(24);
                try {
                    delegatePresupuesto.registrar(modeloPresp);
                } catch (Exception e) {
                }
                for (DetalleConcepto det : listadetalleEgresos) {
                    DetalleEgresos detalle = new DetalleEgresos();
                    detalle.setDprMonto(det.getMonto24());
                    detalle.setPcuCodigo(modeloPresp);
                    detalle.setDcoCodigo(det);
                    delegateDetEgresos.registrar(detalle);
                }
            }
        }
    }

    public void registrarIngresosEst(Preevento pre) {
        //Registrar Estimacion Participantes
        for (EstimacionParticipantes est : listaEstimacionParticipantes) {
            if (!est.getM1()) {//Si ah sido seleccionado
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpaCantidad(est.getCant1());
                estima.setEpafechaInicio(est.getRang().getFechaIni());
                estima.setEpafechaFin(est.getRang().getFechaFin());
                estima.setPreCodigo(pre);
                estima.setTpeCodigo(est.getTip1());
                delegateEstimacion.registrar(estima);
            }
            if (!est.getM2()) {
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpaCantidad(est.getCant2());
                estima.setEpafechaInicio(est.getRang().getFechaIni());
                estima.setEpafechaFin(est.getRang().getFechaFin());
                estima.setPreCodigo(pre);
                estima.setTpeCodigo(est.getTip2());
                delegateEstimacion.registrar(estima);
            }
            if (!est.getM3()) {
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpaCantidad(est.getCant3());
                estima.setEpafechaInicio(est.getRang().getFechaIni());
                estima.setEpafechaFin(est.getRang().getFechaFin());
                estima.setPreCodigo(pre);
                estima.setTpeCodigo(est.getTip3());
                delegateEstimacion.registrar(estima);
            }
            if (!est.getM4()) {
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpaCantidad(est.getCant4());
                estima.setEpafechaInicio(est.getRang().getFechaIni());
                estima.setEpafechaFin(est.getRang().getFechaFin());
                estima.setPreCodigo(pre);
                estima.setTpeCodigo(est.getTip4());
                delegateEstimacion.registrar(estima);
            }
            if (!est.getM5()) {
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpaCantidad(est.getCant5());
                estima.setEpafechaInicio(est.getRang().getFechaIni());
                estima.setEpafechaFin(est.getRang().getFechaFin());
                estima.setPreCodigo(pre);
                estima.setTpeCodigo(est.getTip5());
                delegateEstimacion.registrar(estima);
            }
            if (!est.getM6()) {
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpaCantidad(est.getCant6());
                estima.setEpafechaInicio(est.getRang().getFechaIni());
                estima.setEpafechaFin(est.getRang().getFechaFin());
                estima.setPreCodigo(pre);
                estima.setTpeCodigo(est.getTip6());
                delegateEstimacion.registrar(estima);
            }
        }
        //Registrar Detalle Ingresos
        for (DetIngresosAdapter det : listaIngresosAdapter) {
            if (!det.getM1()) {
                DetalleIngresosEventos deta = new DetalleIngresosEventos();
                deta.setDinMonto(det.getMont1());
                deta.setDinfechaFin(det.getRang().getFechaFin());
                deta.setDinfechaInicio(det.getRang().getFechaIni());
                deta.setPreCodigo(pre);
                deta.setTpeCodigo(det.getTip1());
                deta.setTpiCodigo(det.getTipoIngreso());
                for (TipoIngresoEventos tip : listaIngresos2) {
                    if (tip.getTpiCodigo() == deta.getTpiCodigo().getTpiCodigo()) {
                        deta.setNroCuotas(tip.getNumCuotas());
                    }
                }
                delegateDetIngresos.registrar(deta);
            }
            if (!det.getM2()) {
                DetalleIngresosEventos deta = new DetalleIngresosEventos();
                deta.setDinMonto(det.getMont2());
                deta.setDinfechaFin(det.getRang().getFechaFin());
                deta.setDinfechaInicio(det.getRang().getFechaIni());
                deta.setPreCodigo(pre);
                deta.setTpeCodigo(det.getTip2());
                deta.setTpiCodigo(det.getTipoIngreso());
                for (TipoIngresoEventos tip : listaIngresos2) {
                    if (tip.getTpiCodigo() == deta.getTpiCodigo().getTpiCodigo()) {
                        deta.setNroCuotas(tip.getNumCuotas());
                    }
                }
                delegateDetIngresos.registrar(deta);
            }
            if (!det.getM3()) {
                DetalleIngresosEventos deta = new DetalleIngresosEventos();
                deta.setDinMonto(det.getMont3());
                deta.setDinfechaFin(det.getRang().getFechaFin());
                deta.setDinfechaInicio(det.getRang().getFechaIni());
                deta.setPreCodigo(pre);
                deta.setTpeCodigo(det.getTip3());
                deta.setTpiCodigo(det.getTipoIngreso());
                for (TipoIngresoEventos tip : listaIngresos2) {
                    if (tip.getTpiCodigo() == deta.getTpiCodigo().getTpiCodigo()) {
                        deta.setNroCuotas(tip.getNumCuotas());
                    }
                }
                delegateDetIngresos.registrar(deta);
            }
            if (!det.getM4()) {
                DetalleIngresosEventos deta = new DetalleIngresosEventos();
                deta.setDinMonto(det.getMont4());
                deta.setDinfechaFin(det.getRang().getFechaFin());
                deta.setDinfechaInicio(det.getRang().getFechaIni());
                deta.setPreCodigo(pre);
                deta.setTpeCodigo(det.getTip4());
                deta.setTpiCodigo(det.getTipoIngreso());
                for (TipoIngresoEventos tip : listaIngresos2) {
                    if (tip.getTpiCodigo() == deta.getTpiCodigo().getTpiCodigo()) {
                        deta.setNroCuotas(tip.getNumCuotas());
                    }
                }
                delegateDetIngresos.registrar(deta);
            }
            if (!det.getM5()) {
                DetalleIngresosEventos deta = new DetalleIngresosEventos();
                deta.setDinMonto(det.getMont5());
                deta.setDinfechaFin(det.getRang().getFechaFin());
                deta.setDinfechaInicio(det.getRang().getFechaIni());
                deta.setPreCodigo(pre);
                deta.setTpeCodigo(det.getTip5());
                deta.setTpiCodigo(det.getTipoIngreso());
                for (TipoIngresoEventos tip : listaIngresos2) {
                    if (tip.getTpiCodigo() == deta.getTpiCodigo().getTpiCodigo()) {
                        deta.setNroCuotas(tip.getNumCuotas());
                    }
                }
                delegateDetIngresos.registrar(deta);
            }
            if (!det.getM6()) {
                DetalleIngresosEventos deta = new DetalleIngresosEventos();
                deta.setDinMonto(det.getMont6());
                deta.setDinfechaFin(det.getRang().getFechaFin());
                deta.setDinfechaInicio(det.getRang().getFechaIni());
                deta.setPreCodigo(pre);
                deta.setTpeCodigo(det.getTip6());
                deta.setTpiCodigo(det.getTipoIngreso());
                for (TipoIngresoEventos tip : listaIngresos2) {
                    if (tip.getTpiCodigo() == deta.getTpiCodigo().getTpiCodigo()) {
                        deta.setNroCuotas(tip.getNumCuotas());
                    }
                }
                delegateDetIngresos.registrar(deta);
            }
        }
    }

    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Docentes Evento">
    public String agregarDocente() {
        InstructorEvento instructor = new InstructorEvento();
        try {
            if (!busq) {
                if (!validarStrings(dni)) {
                    mostrarMensaje("ERROR: ", "Debe Ingresar un DNI valido", FacesMessage.SEVERITY_ERROR);
                } else {
                    if (delegatePersona.buscarDNI(dni) != null) {
                        mostrarMensaje("ERROR: ", "DNI ya existe ingrese otro", FacesMessage.SEVERITY_ERROR);
                    } else {
                        persona.setPerNroDNI(dni);
                        instructor.setPerCodigo(persona);
                        instructor.setRegistrado(busq);
                        listaInstructores.add(instructor);
                    }
                }
            } else {
                persona.setPerNroDNI(dni);
                instructor.setPerCodigo(persona);
                instructor.setRegistrado(busq);
                listaInstructores.add(instructor);
            }
        } catch (Exception e) {
            mostrarMensaje("ERROR: ", "En agregar isntructor", FacesMessage.SEVERITY_ERROR);
            System.out.println("Error agregarInstructor " + e.toString());
        }
        persona = new PersonaNatural();
        dni = "";
        busq = false;
        return "";
    }

    public String quitarDocente() {
        try {
            listaInstructores.remove(instructorSeleccionado);
        } catch (Exception e) {
        }
        return "";
    }

    public String buscarPersonaxDNI() {
        try {
            persona = delegatePersona.buscarXDNI(dni);
            if (persona != null) {  //corregido por lizardo
                busq = true;
                if (persona.getSolCodigo() > 0) {
                } else {
                    busq = false;
                }
            } else {
                busq = true;
            }
        } catch (Exception ex) {
//            persona = new PersonaNatural();
            System.out.println("Error buscarPersonaxDni " + ex.toString());
            busq = false;
        }
        return "";
    }

    public String modificarInstructor() {
        try {
            listaInstructores = new ArrayList<InstructorEvento>();
            listaInstructores = delegateInstructor.listarPorEvento(preEventoSeleccionado);
        } catch (Exception e) {
        }
        return "instructor";
    }

    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Navegaciones entre Paginas">
    public String navegarEditar() {
        System.out.println("preenvento: "+preEventoSeleccionado.getPreCodigo());
        return "editar";
    }

    public String navegarPresupuesto() {
        try {
            preEventoSeleccionado = new Preevento();
            preEventoSeleccionado = preEventoVerifPresupuesto;
            modificarPresupuesto();
        } catch (Exception e) {
        }
        preEventoSeleccionado = new Preevento();
        return "modificar";
    }

    public String modificarDetalle() {
        listarContenidoPresupuesto();
        return "detalle";
    }
    // // </editor-fold>

    //<editor-fold defaultstate="collapsed" desc="Cambios de Estado">
    public String habilitarModulo() {
        switch (nroMeses) {
            case 1:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(false);
                    listadetalleEgresos.get(i).setBand3(false);
                    listadetalleEgresos.get(i).setBand4(false);
                    listadetalleEgresos.get(i).setBand5(false);
                    listadetalleEgresos.get(i).setBand6(false);
                    listadetalleEgresos.get(i).setBand7(false);
                }
                break;
            case 2:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(false);
                    listadetalleEgresos.get(i).setBand4(false);
                    listadetalleEgresos.get(i).setBand5(false);
                    listadetalleEgresos.get(i).setBand6(false);
                    listadetalleEgresos.get(i).setBand7(false);
                }
                break;
            case 3:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(false);
                    listadetalleEgresos.get(i).setBand5(false);
                    listadetalleEgresos.get(i).setBand6(false);
                    listadetalleEgresos.get(i).setBand7(false);
                }
                break;
            case 4:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(false);
                    listadetalleEgresos.get(i).setBand6(false);
                    listadetalleEgresos.get(i).setBand7(false);
                }
                break;
            case 5:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                }
                break;
            case 6:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                }
                break;
            case 7:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                }
                break;
            case 8:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                }
                break;
            case 9:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                }
                break;
            case 10:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                }
                break;
            case 11:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                }
                break;
            case 12:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                }
                break;
            case 13:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                }
                break;
            case 14:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                }
                break;
            case 15:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                }
                break;
            case 16:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                }
                break;
            case 17:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                }
                break;
            case 18:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                }
                break;
            case 19:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                    listadetalleEgresos.get(i).setBand19(true);
                }
                break;
            case 20:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                    listadetalleEgresos.get(i).setBand19(true);
                    listadetalleEgresos.get(i).setBand20(true);
                }
                break;
            case 21:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                    listadetalleEgresos.get(i).setBand19(true);
                    listadetalleEgresos.get(i).setBand20(true);
                    listadetalleEgresos.get(i).setBand21(true);
                }
                break;
            case 22:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                    listadetalleEgresos.get(i).setBand19(true);
                    listadetalleEgresos.get(i).setBand20(true);
                    listadetalleEgresos.get(i).setBand21(true);
                    listadetalleEgresos.get(i).setBand22(true);
                }
                break;
            case 23:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                    listadetalleEgresos.get(i).setBand19(true);
                    listadetalleEgresos.get(i).setBand20(true);
                    listadetalleEgresos.get(i).setBand21(true);
                    listadetalleEgresos.get(i).setBand22(true);
                    listadetalleEgresos.get(i).setBand23(true);
                }
                break;
            case 24:
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(true);
                    listadetalleEgresos.get(i).setBand3(true);
                    listadetalleEgresos.get(i).setBand4(true);
                    listadetalleEgresos.get(i).setBand5(true);
                    listadetalleEgresos.get(i).setBand6(true);
                    listadetalleEgresos.get(i).setBand7(true);
                    listadetalleEgresos.get(i).setBand8(true);
                    listadetalleEgresos.get(i).setBand9(true);
                    listadetalleEgresos.get(i).setBand10(true);
                    listadetalleEgresos.get(i).setBand11(true);
                    listadetalleEgresos.get(i).setBand12(true);
                    listadetalleEgresos.get(i).setBand13(true);
                    listadetalleEgresos.get(i).setBand14(true);
                    listadetalleEgresos.get(i).setBand15(true);
                    listadetalleEgresos.get(i).setBand16(true);
                    listadetalleEgresos.get(i).setBand17(true);
                    listadetalleEgresos.get(i).setBand18(true);
                    listadetalleEgresos.get(i).setBand19(true);
                    listadetalleEgresos.get(i).setBand20(true);
                    listadetalleEgresos.get(i).setBand21(true);
                    listadetalleEgresos.get(i).setBand22(true);
                    listadetalleEgresos.get(i).setBand23(true);
                    listadetalleEgresos.get(i).setBand24(true);
                }
                break;
        }
        return "";
    }

    public String cambiarEstado() {
        try {
            if (preEvento.getEstado() == false) {
                for (int i = 0; i < listadetalleEgresos.size(); i++) {
                    listadetalleEgresos.get(i).setBand2(false);
                    listadetalleEgresos.get(i).setMonto2(0.0);
                    listadetalleEgresos.get(i).setBand3(false);
                    listadetalleEgresos.get(i).setMonto3(0.0);
                    listadetalleEgresos.get(i).setBand4(false);
                    listadetalleEgresos.get(i).setMonto4(0.0);
                    listadetalleEgresos.get(i).setBand5(false);
                    listadetalleEgresos.get(i).setMonto5(0.0);
                    listadetalleEgresos.get(i).setBand6(false);
                    listadetalleEgresos.get(i).setMonto6(0.0);
                    listadetalleEgresos.get(i).setBand7(false);
                    listadetalleEgresos.get(i).setMonto7(0.0);
                    listadetalleEgresos.get(i).setBand8(false);
                    listadetalleEgresos.get(i).setMonto8(0.0);
                    listadetalleEgresos.get(i).setBand9(false);
                    listadetalleEgresos.get(i).setMonto9(0.0);
                    listadetalleEgresos.get(i).setBand10(false);
                    listadetalleEgresos.get(i).setMonto10(0.0);
                    listadetalleEgresos.get(i).setBand11(false);
                    listadetalleEgresos.get(i).setMonto11(0.0);
                    listadetalleEgresos.get(i).setBand12(false);
                    listadetalleEgresos.get(i).setMonto12(0.0);
                    listadetalleEgresos.get(i).setBand13(false);
                    listadetalleEgresos.get(i).setMonto13(0.0);
                    listadetalleEgresos.get(i).setBand14(false);
                    listadetalleEgresos.get(i).setMonto14(0.0);
                    listadetalleEgresos.get(i).setBand15(false);
                    listadetalleEgresos.get(i).setMonto15(0.0);
                    listadetalleEgresos.get(i).setBand16(false);
                    listadetalleEgresos.get(i).setMonto16(0.0);
                    listadetalleEgresos.get(i).setBand17(false);
                    listadetalleEgresos.get(i).setMonto17(0.0);
                    listadetalleEgresos.get(i).setBand18(false);
                    listadetalleEgresos.get(i).setMonto18(0.0);
                    listadetalleEgresos.get(i).setBand19(false);
                    listadetalleEgresos.get(i).setMonto19(0.0);
                    listadetalleEgresos.get(i).setBand20(false);
                    listadetalleEgresos.get(i).setMonto20(0.0);
                    listadetalleEgresos.get(i).setBand21(false);
                    listadetalleEgresos.get(i).setMonto21(0.0);
                    listadetalleEgresos.get(i).setBand22(false);
                    listadetalleEgresos.get(i).setMonto22(0.0);
                    listadetalleEgresos.get(i).setBand23(false);
                    listadetalleEgresos.get(i).setMonto23(0.0);
                    listadetalleEgresos.get(i).setBand24(false);
                    listadetalleEgresos.get(i).setMonto24(0.0);
                }
            }

        } catch (Exception e) {
        }
        return "";
    }
    // // </editor-fold>

    public String registraNuevoPreEvento(){

        try {

            //Registrar PreEvento
            preEvento.setPreEstado("INICIADO");
            preEvento.setPrefechaRegistro(new Date());
            preEvento.setPrefechaActualizacion(new Date());
//            preEvento.setPreDetalle(editor);
//            preEvento.setPreUtilidad(utilidad);
//            preEvento.setPreIngresos(ingresos);
//            preEvento.setPreEgresos(egresos);
            preEvento.setPreActivo(true);
            preEvento.setPreAprobacion(0);
            preEvento.setPreNroVecesTramitado(0);
            if (preEvento.getEstado()) {
                preEvento.setPreNroModulos(nroModulos);
                preEvento.setNroMesesPresupuesto(nroMeses);
                //preEvento.setPreTipo("CU");
            } else {
                preEvento.setPreNroModulos(1);
                preEvento.setNroMesesPresupuesto(1);
                //preEvento.setPreTipo("EV");
            }
                     //ES CURSO O EVENTO?
            String preTipo = verificarTipo();
            if (preTipo == null) {
                mostrarMensaje("Error: ", "Debe existir al menos un tipo de evento", FacesMessage.SEVERITY_ERROR);
                return "";
            }
            preEvento.setPreTipo(preTipo);

            HttpServletRequest request = ControladorAbstracto.getRequest();
            HttpSession sesion = request.getSession();
            System.out.println("codigo: " + sesion.getAttribute("sCodsol"));
            System.out.println("cuenta: " + sesion.getAttribute("sCuenta"));
            Cookie[] cookies = ControladorAbstracto.getRequest().getCookies();
            //String codUsuario = getCookieValue(cookies, "Usuario", "nulo");
            String codUsuario = Utiles.getCookieValue(cookies, "Usuario", "nulo");
            if(!codUsuario.equals("nulo")){
//                            UsuarioWeb usuario = new UsuarioWeb();
//                            usuario = delegate. find(new Long(codUsuario));
                codPersona = new Long(codUsuario);
            }
            //Lizardo
            //integracion con modulo tramite
            Transaccion transaccion = new Transaccion();
            transaccion.setTraFecha(new Date());
            transaccion.setTraEstado(true); //iniciado
            Solicitante solicitante = new Solicitante();
            SolicitanteDelegate delegadoSolicitante = new SolicitanteDelegate();
            System.out.println("codigo persona: " + codPersona);
            //solicitante = delegadoSolicitante.buscarSolicitante(new Long(codPersona));
            solicitante = delegadoSolicitante.buscarSolicitante(codPersona);
            Expediente expediente = new Expediente();
            expediente.setExpFecha(new Date());
            expediente.setExpNrofolios(2);  //cualquiera
            delegate.RegistrarExpediente(expediente);
            transaccion.setFkSolCodigo(solicitante); //admin por mientras
            transaccion.setFkSolicitado(solicitante); //el mismo usuario
            Tramite tramite = new Tramite();
            tramite = delegate.buscarNombreTramite("Solicitud de Apertura de Evento Interno");
            transaccion.setFkTrmCodigo(tramite);//tipo de tramite
            transaccion.setFkExpCodigo(expediente);
            transaccion.setTraRecepcion(new Short("0"));    //por correo
            delegate.registrarTransaccion(transaccion);
            preEvento.setTranumTramite(transaccion.getTraCodigo());
            //fin de la integracion con tramite-Lizardo
            //recien crea el preevento
            delegate.registrar(preEvento);
            agregarDatos = true;

            return null;
        } catch (Exception ex) {
            System.out.println("error : "+ex.getMessage());
            return null;
        }
    }
    //<editor-fold defaultstate="collapsed" desc="Registrar PreEvento">
    public String registrarNuevo() {
        try {
            //Validar datos del PreEvento
            if (validarStrings(preEvento.getPreNombre())) {
                if (validarFechas(preEvento.getPrefechaInicio(), preEvento.getPrefechaFin())) {
                    calcularIngresos();
                    calcularEgresos();
                    if (!utilidad.equals(null) && !utilidad.equals(0.0)) {
                        //Validar datos del Presupuesto
                        //Ingresos/Tarifario
                        if (listaIngresosAdapter.size() > 0) {
                        } else {
                            mostrarMensaje("Error: ", "Debe elegir por lo menos un ingreso", FacesMessage.SEVERITY_ERROR);
                            return "";
                        }
                        //Egresos
                        //Organizador
                        if (listaOrganizadores.size() > 0) {
                        } else {
                            mostrarMensaje("Error: ", "Debe existir por lo menos un organizador", FacesMessage.SEVERITY_ERROR);
                            return "";
                        }
                        //Instructores
                        if (listaInstructores.size() > 0) {
                        } else {
                            mostrarMensaje("Error: ", "Debe existir por lo menos un instructor", FacesMessage.SEVERITY_ERROR);
                            return "";
                        }
                        //Ambientes
                        if (listaCalendario1.size() > 0) {
                        } else {
                            mostrarMensaje("Error: ", "Debe existir por lo menos un ambiente", FacesMessage.SEVERITY_ERROR);
                            return "";
                        }
                        //dameCodigoPersona();
                        HttpServletRequest request = ControladorAbstracto.getRequest();
                        HttpSession sesion = request.getSession();
                        System.out.println("codigo: " + sesion.getAttribute("sCodsol"));
                        System.out.println("cuenta: " + sesion.getAttribute("sCuenta"));
                        Cookie[] cookies = ControladorAbstracto.getRequest().getCookies();
                        //String codUsuario = getCookieValue(cookies, "Usuario", "nulo");
                        String codUsuario = Utiles.getCookieValue(cookies, "Usuario", "nulo");
                        if(!codUsuario.equals("nulo")){
//                            UsuarioWeb usuario = new UsuarioWeb();
//                            usuario = delegate. find(new Long(codUsuario));
                            codPersona = new Long(codUsuario);
                        }

//                        codPersona = (sesion.getAttribute("sCodsol") != null) ? (Long) sesion.getAttribute("sCodsol") : 0L;
//                        if (codPersona == 0L) {
//                            codPersona = 9603L;
//                            //mostrarMensaje("ERROR: ", "El usuario a perdido la sesión o no se a logueado!", FacesMessage.SEVERITY_ERROR);
//                            //return "";
//                        }
                        //Registrar PreEvento
                        preEvento.setPreEstado("INICIADO");
                        preEvento.setPrefechaRegistro(new Date());
                        preEvento.setPrefechaActualizacion(new Date());
                        preEvento.setPreDetalle(editor);
                        preEvento.setPreUtilidad(utilidad);
                        preEvento.setPreIngresos(ingresos);
                        preEvento.setPreEgresos(egresos);
                        preEvento.setPreActivo(true);
                        preEvento.setPreAprobacion(0);
                        preEvento.setPreNroVecesTramitado(0);
                        if (preEvento.getEstado()) {
                            preEvento.setPreNroModulos(nroModulos);
                            preEvento.setNroMesesPresupuesto(nroMeses);
                            //preEvento.setPreTipo("CU");
                        } else {
                            preEvento.setPreNroModulos(1);
                            preEvento.setNroMesesPresupuesto(1);
                            //preEvento.setPreTipo("EV");
                        }
                        //Lizardo
                        //ES CURSO O EVENTO?
                        String preTipo = verificarTipo();
                        if (preTipo == null) {
                            mostrarMensaje("Error: ", "Debe existir al menos un tipo de evento", FacesMessage.SEVERITY_ERROR);
                            return "";
                        }
                        preEvento.setPreTipo(preTipo);

                        //Lizardo
                        //integracion con modulo tramite
                        Transaccion transaccion = new Transaccion();
                        transaccion.setTraFecha(new Date());
                        transaccion.setTraEstado(true); //iniciado
                        Solicitante solicitante = new Solicitante();
                        SolicitanteDelegate delegadoSolicitante = new SolicitanteDelegate();
                        System.out.println("codigo persona: " + codPersona);
                        //solicitante = delegadoSolicitante.buscarSolicitante(new Long(codPersona));
                        solicitante = delegadoSolicitante.buscarSolicitante(codPersona);
                        Expediente expediente = new Expediente();
                        expediente.setExpFecha(new Date());
                        expediente.setExpNrofolios(2);  //cualquiera
                        delegate.RegistrarExpediente(expediente);
                        transaccion.setFkSolCodigo(solicitante); //admin por mientras
                        transaccion.setFkSolicitado(solicitante); //el mismo usuario
                        Tramite tramite = new Tramite();
                        tramite = delegate.buscarNombreTramite("Solicitud de Apertura de Evento Interno");
                        transaccion.setFkTrmCodigo(tramite);//tipo de tramite
                        transaccion.setFkExpCodigo(expediente);
                        transaccion.setTraRecepcion(new Short("0"));    //por correo
                        delegate.registrarTransaccion(transaccion);
                        preEvento.setTranumTramite(transaccion.getTraCodigo());
                        //fin de la integracion con tramite-Lizardo
                        //recien crea el preevento
                        delegate.registrar(preEvento);
                        //REGISTRAR CURSO SI ES NECESARIO
//                        if (preTipo.compareTo("CU")==0) {
//                            Curso cu = new Curso();
//                            cu.setPreevento(preEvento);
//                            cu.setCurVacantes(0);
//                            cu.setCurnroSesiones(0);
//                            cu.setCurfaltaMax(0);
//                            cu.setCurNotaMinima(0D);
//                            delegateCurso.create(cu);
//                            cu = null;
//                        }
//                        preTipo = null;

                        //Registramos el Presupuesto,Egresos
                        registrarPresupuesto(preEvento);
                        //Registramos los Ingresos
                        registrarIngresosEst(preEvento);
                        //Registrar Organizadores
                        for (OrganizadorEvento org : listaOrganizadores) {
                            org.setPreCodigo(preEvento);
                            delegateOrganizador.registrar(org);
                        }
                        //Registrar Instructores
                        PersonaNaturalDelegate delegatePersonaN = new PersonaNaturalDelegate();
                        for (InstructorEvento ins : listaInstructores) {
                            ins.setPreCodigo(preEvento);
                            try {
                                if (ins.isRegistrado()) {
                                    System.out.println("--If");
                                    ins.setPerCodigo(delegatePersonaN.buscarXDNI(ins.getPerCodigo().getPerNroDNI()));
                                } else {
                                    System.out.println("--else");
                                    delegatePersonaN.registrar(ins.getPerCodigo());
                                }
                            } catch (Exception e) {
                                delegatePersonaN.registrar(ins.getPerCodigo());
                            }
                            ins.setInenroHoras(0); //inicialmente no tiene horas
                            ins.setInePrioridad(false); //inicialmente no tiene prioridad
                            System.out.println("REVISANDO DATOS DEL INSTRUCTOR");
                            System.out.println("------------------------------");
                            System.out.println("ineCodigo: " + ins.getIneCodigo());
                            System.out.println("preCodigo: " + ins.getPreCodigo());
                            System.out.println("perCodigo: " + ins.getPerCodigo());
                            System.out.println("inePrioridad: " + ins.getInePrioridad());
                            
                            delegateInstructor.registrar(ins);
                        }
                        //Registrar la Reserva de Ambientes
                        for (CalendarioAmbientesAdapter cal : listaCalendario1) {
                            ReservaAmbiente res = new ReservaAmbiente();
                            res.setReaEstado("RESERVADO");
                            if (cal.getTipo() == 0) {
                                res.setAmbCodigo(cal.getAmbiente());
                            } else {
                                res.setSerCodigo(cal.getServicio());
                            }
                            res.setEveCodigo(preEvento);
//                            res.setReaFecha(fechaAmbiente);   //corregido por lizardo
                            res.setReaFecha(cal.getFecha());    //corregido por lizardo
                            res.setReaTipoae(cal.getTipo());
                            res.setReaTipoec(0);
                            res.setReahoraInicio(cal.getHoraInicio());
                            res.setReahoraFin(cal.getHoraFin());
                            delegateReserva.registrar(res);
                        }
                        //Lizardo
                        //Registrar Modulo Curso 
                        ModuloCursoDelegate delegadoModulo = new ModuloCursoDelegate();
                        for (ModuloCurso mod : listaModulo) {
                            mod.setPreCodigo(preEvento);
                            delegadoModulo.create(mod);
                        }
                        delegadoModulo = null;
                        inicializar();
                        mostrarMensaje("Exito: ", "El registro del PreEvento se realizo exitosamente.", FacesMessage.SEVERITY_INFO);
                    } else {
                        mostrarMensaje("Error: ", "La utilidad del Evento es incorrecta", FacesMessage.SEVERITY_ERROR);
                        //inicializar();
                        return "";
                    }

                } else {
                    mostrarMensaje("Error: ", "Ingrese Fecha Inicio y Fin Correctamnete.", FacesMessage.SEVERITY_ERROR);
                    //inicializar();
                    return "";
                }
            } else {
                mostrarMensaje("Error: ", "Asegurese de haber el nombre del Evento.", FacesMessage.SEVERITY_ERROR);
                //inicializar();
                return "";
            }
        } catch (Exception ex) {
            mostrarMensaje("ERORR: ", "Asegurese de haber ingresado todos los datos del Evento correctamente.", FacesMessage.SEVERITY_ERROR);
            //mostrarMensaje("FATAL: ", ex.getMessage(), FacesMessage.SEVERITY_FATAL);
            System.out.println("FATAL: " + ex.getMessage());
            //inicializar();
            return "";
        }
        return "";
    }

    public String dameCodigoPersona() {
//        HttpServletRequest request =  ControladorAbstracto.getRequest();
//        HttpSession sesion = request.getSession();
//        codPersona = (sesion.getAttribute("sCodsol") != null) ? (Long)sesion.getAttribute("sCodsol") : 0L;
//        if (codPersona == 0L) {
//            mostrarMensaje("ERROR: ", "El usuario a perdido la sesión o no se a logueado!", FacesMessage.SEVERITY_ERROR);
//            return "";
//        }

        return null;
    }

    public String registrarCeremonia() {
        try {
            //Validar datos del PreEvento
            try {
//                if (preEvento.getPrefechaInicio().compareTo(new Date()) >= 0) {
                    if (listadetalleEgresos.size() > 0) {
                        if (listaCalendario1.size() > 0) {
                            preEvento.setPrefechaFin(preEvento.getPrefechaInicio());
                            preEvento.setPreNombre("Ceremonia Colegiación");
                            preEvento.setPreEstado("APROBADO");
                            TipoEvento tipo = new TipoEvento(8);
                            preEvento.setTevCodigo(tipo);
                            preEvento.setPrefechaRegistro(new Date());
                            preEvento.setPrefechaActualizacion(new Date());
                            preEvento.setPreTipo("EV");
                            preEvento.setPreNroModulos(0);
                            preEvento.setNroMesesPresupuesto(1);
                            preEvento.setPreAprobacion(3);
                            preEvento.setPreActivo(true);
                            delegate.registrar(preEvento);
                            //Presupuesto
                            ModeloPresupuesto modeloPresp = new ModeloPresupuesto();
                            modeloPresp.setPcufechaCreacion(new Date());
                            modeloPresp.setPcufechaActualizacion(new Date());
                            modeloPresp.setPreevento(preEvento);
                            modeloPresp.setPcuEstado(true);
                            modeloPresp.setPcuNroModulos(1);
                            try {
                                delegatePresupuesto.registrar(modeloPresp);
                            } catch (Exception e) {
                            }
                            for (DetalleConcepto det : listadetalleEgresos) {
                                DetalleEgresos detalle = new DetalleEgresos();
                                detalle.setDprMonto(det.getMonto1());
                                detalle.setPcuCodigo(modeloPresp);
                                detalle.setDcoCodigo(det);
                                detalle.setDprEstado(true);
                                delegateDetEgresos.registrar(detalle);
                            }
                            //Evento
                            Evento eve = new Evento();
                            EventoDelegate deleEv = new EventoDelegate();
                            eve.setEveCodigo(preEvento.getPreCodigo());
                            eve.setEveEstado(1);
                            eve.setEveFecharegistro(new Date());
                            deleEv.registrarEvento(eve);
                            //Reservar Ambiente
                            for (CalendarioAmbientesAdapter cal : listaCalendario1) {
                                ReservaAmbiente res = new ReservaAmbiente();
                                res.setReaEstado("RESERVADO");
                                if (cal.getTipo() == 0) {
                                    res.setAmbCodigo(ambiente);
                                } else {
                                    res.setSerCodigo(equipo);
                                }
                                res.setEveCodigo(preEvento);
                                res.setReaFecha(fechaAmbiente);
                                res.setReaTipoae(cal.getTipo());
                                res.setReaTipoec(0);
                                res.setReahoraInicio(cal.getHoraInicio());
                                res.setReahoraFin(cal.getHoraFin());
                                delegateReserva.registrar(res);
                            }
                            inicializar();
                            mostrarMensaje("Exito: ", "Se registro con exito la ceremonia de colegiación", FacesMessage.SEVERITY_INFO);
                        } else {
                            mostrarMensaje("Error: ", "Seleccione por lo menos un ambiente", FacesMessage.SEVERITY_ERROR);
                        }
                    } else {
                        mostrarMensaje("Error: ", "Seleccione por lo menos un gasto", FacesMessage.SEVERITY_ERROR);
                    }
//                } else {
//                    mostrarMensaje("Error: ", "Ingrese fecha del Evento correctamente.", FacesMessage.SEVERITY_ERROR);
//                }
            } catch (Exception e) {
                mostrarMensaje("Error: ", "Ingrese fecha  del Evento correctamente.", FacesMessage.SEVERITY_ERROR);
                System.out.println("FATAL: " + e.getMessage());
            }

        } catch (Exception e) {
            System.out.println("FATAL: " + e.getMessage());
        }
        return null;
    }

    // // </editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Aprobar y Tramitar PreEvento">
    public String tramitarEvento() {
        try {
            preEventoTramitar.setPreEstado("TRAMITADO");
            preEventoTramitar.setPreNroVecesTramitado(1);
            delegate.actualizar(preEventoTramitar);
            inicializar();
        } catch (Exception e) {
        }
        cargarEventosPorTramitar();
        return "";
    }

    public String desaprobarContenido() {
        try {
            if (preEventoSeleccionado.getPreEstado().equals("PRESUPUESTO DESAPROBADO")) {
                preEventoVerifContenido.setPreEstado("DESAPROBADO");
            } else {
                preEventoVerifContenido.setPreEstado("CONTENIDO DESAPROBADO");
            }
            delegate.actualizar(preEventoVerifContenido);
        } catch (Exception e) {
        }
        cargarEventosVerifContenido();
        return "listar";
    }

    public String desaprobarPresupuesto() {
        try {
            if (preEventoSeleccionado.getPreEstado().equals("CONTENIDO DESAPROBADO")) {
                preEventoVerifContenido.setPreEstado("DESAPROBADO");
            } else {
                preEventoVerifContenido.setPreEstado("PRESUPUESTO DESAPROBADO");
            }
            delegate.actualizar(preEventoVerifContenido);
        } catch (Exception e) {
        }
        cargarEventosVerifContenido();
        return "listar";
    }

    public String aprobarContenido() {
        try {
            cargarEventosVerifContenido();
            if (preEventoVerifContenido.getPreAprobacion() == 1) {
                preEventoVerifContenido.setPreAprobacion(3);
                preEventoVerifContenido.setPreEstado("APROBADO");
                delegate.actualizar(preEventoVerifContenido);
                if (preEventoVerifContenido.getPreTipo().equals("EV")) {
                    //Guardar al Evento
                    Evento eve = new Evento();
                    eve.setEveCodigo(preEventoVerifContenido.getPreCodigo());
                    eve.setEveFecharegistro(new Date());
                    eve.setEveEstado(1);
                    eve.setPreevento(preEventoVerifContenido);
                    try {
                        delegateEvento.registrarEvento(eve);
                    } catch (Exception e) {
                        System.out.println("FATAL: " + e.getMessage());
                    }
                } else {
                    //Guardar Curso
                    Curso cur = new Curso();
                    cur.setEveCodigo(preEventoVerifContenido.getPreCodigo());
                    if (preEventoVerifContenido.getPreNroModulos() != null) {
                        cur.setCurnroSesiones(preEventoVerifContenido.getPreNroModulos());
                    } else {
                        cur.setCurnroSesiones(0);
                    }
                    if (preEventoVerifContenido.getPreVacanteTemporal() != null) {
                        cur.setCurVacantes(preEventoVerifContenido.getPreVacanteTemporal());
                    } else {
                        cur.setCurVacantes(0);
                    }
                    cur.setCurfaltaMax(0);
                    cur.setEveEstado(1);
                    cur.setCurNotaMinima(0.0);
                    cur.setEveFecharegistro(new Date());
                    try {
                        delegateCurso.create(cur);
                    } catch (Exception e) {
                        System.out.println("FATAL: " + e.getMessage());
                    }
                }
            } else {
                preEventoVerifContenido.setPreAprobacion(2);
                delegate.actualizar(preEventoVerifContenido);
            }
            inicializar();
            return "listar";
        } catch (Exception e) {
            try {
                preEventoVerifContenido.setPreAprobacion(2);
                delegate.actualizar(preEventoVerifContenido);
            } catch (Exception ex) {
                Logger.getLogger(PreEventoController.class.getName()).log(Level.SEVERE, null, ex);
            }
            inicializar();
            return "listar";
        }
    }

    public String aprobarPresupuesto() {
        try {
            cargarEventosVerifPresupuesto();
            if (preEventoVerifPresupuesto.getPreAprobacion() == 2) {
                preEventoVerifPresupuesto.setPreAprobacion(3);
                preEventoVerifPresupuesto.setPreEstado("APROBADO");
                delegate.actualizar(preEventoVerifPresupuesto);
                if (preEventoVerifPresupuesto.getPreTipo().equals("EV")) {
                    //Guardar al Evento
                    Evento eve = new Evento();
                    eve.setEveCodigo(preEventoVerifPresupuesto.getPreCodigo());
                    eve.setEveFecharegistro(new Date());
                    eve.setEveEstado(1);
                    eve.setPreevento(preEventoVerifPresupuesto);
                    try {
                        delegateEvento.registrarEvento(eve);
                    } catch (Exception e) {
                        System.out.println("FATAL: " + e.getMessage());
                    }
                } else {
                    //Guardar Curso
                    Curso cur = new Curso();
                    cur.setEveCodigo(preEventoVerifPresupuesto.getPreCodigo());
                    if (preEventoVerifPresupuesto.getPreNroModulos() != null) {
                        cur.setCurnroSesiones(preEventoVerifPresupuesto.getPreNroModulos());
                    } else  {
                        cur.setCurnroSesiones(0);
                    }
                    if (preEventoVerifPresupuesto.getPreVacanteTemporal() != null) {
                        cur.setCurVacantes(preEventoVerifPresupuesto.getPreVacanteTemporal());
                    } else {
                        cur.setCurVacantes(0);
                    }
                    cur.setCurfaltaMax(0);
                    cur.setEveEstado(1);
                    cur.setCurNotaMinima(0.0);
                    cur.setEveFecharegistro(new Date());
                    try {
                        delegateCurso.create(cur);
                    } catch (Exception e) {
                        System.out.println("FATAL: " + e.getMessage());
                    }
                }
                inicializar();
            } else {
                preEventoVerifPresupuesto.setPreAprobacion(1);
                delegate.actualizar(preEventoVerifPresupuesto);
                inicializar();
            }
            inicializar();
            return "listar";
        } catch (Exception e) {
            preEventoVerifPresupuesto.setPreAprobacion(1);
            try {
                delegate.actualizar(preEventoVerifPresupuesto);
            } catch (Exception ex) {
                Logger.getLogger(PreEventoController.class.getName()).log(Level.SEVERE, null, ex);
            }
            inicializar();
        }

        return "";
    }

    public String navegarModifContenido() {
        return "verificar";
    }

    public String navegarModifPresupuesto() {
        try {
            preEventoSeleccionado = preEventoVerifPresupuesto;
            modifPresupuesto();
        } catch (Exception e) {
        }
        return "verificar";
    }
    // // </editor-fold>

    public String agregarIngresos() {
        try {
            listaDetalleIngresos.clear();
            listaIngresosAdapter.clear();
            listaEstimacionParticipantes.clear();
            if (listaRangos.size() > 0) {
                if (listaTParticipantes1.size() > 0) {
                    if (listaIngresos1.size() > 0) {
                        //Agregar al Adapter
                        for (RangoMatriculas ran : listaRangos) {
                            for (TipoIngresoEventos ting : listaIngresos1) {
                                DetIngresosAdapter det = new DetIngresosAdapter();
                                det.setTipoIngreso(ting);
                                det.setRang(ran);
                                Double monto;
                                for (TipoParticipanteEvento tipe : listaTParticipantes1) {
                                    Integer tpeCodigo = tipe.getTpeCodigo();
                                    switch (tpeCodigo) {
                                        case 1:
                                            det.setM1(false);
                                            det.setTip1(tipe);
                                            monto = tipe.getMonto();
                                            det.setMont1(monto);
                                            break;
                                        case 2:
                                            det.setM2(false);
                                            det.setTip2(tipe);
                                            monto = tipe.getMonto();
                                            det.setMont2(monto);
                                            break;
                                        case 3:
                                            det.setM3(false);
                                            det.setTip3(tipe);
                                            monto = tipe.getMonto();
                                            det.setMont3(monto);
                                            break;
                                        case 4:
                                            det.setM4(false);
                                            det.setTip4(tipe);
                                            monto = tipe.getMonto();
                                            det.setMont4(monto);
                                            break;
                                        case 5:
                                            det.setM5(false);
                                            det.setTip5(tipe);
                                            monto = tipe.getMonto();
                                            det.setMont5(monto);
                                            break;
                                        case 6:
                                            det.setM6(false);
                                            det.setTip6(tipe);
                                            monto = tipe.getMonto();
                                            det.setMont6(monto);
                                            break;
                                    }
                                }
                                listaIngresosAdapter.add(det);
                            }
                        }

                    } else {
                        mostrarMensaje("Error", "Seleccione al Menos un Tipo de Ingreso", FacesMessage.SEVERITY_ERROR);
                        return null;
                    }
                } else {
                    mostrarMensaje("Error", "Seleccione al Menos un Participante", FacesMessage.SEVERITY_ERROR);
                    return null;
                }
            } else {
                mostrarMensaje("Error", "Ingrese al menos un rango", FacesMessage.SEVERITY_ERROR);
                return null;
            }
        } catch (Exception e) {
            System.out.println("---error..." + e.toString());
            return null;
        }
        //Agregar Estimacion Participantes
        try {
            for (RangoMatriculas ran : listaRangos) {
                EstimacionParticipantes estima = new EstimacionParticipantes();
                estima.setEpafechaFin(ran.getFechaFin());
                estima.setEpafechaInicio(ran.getFechaIni());
                for (TipoParticipanteEvento tipe : listaTParticipantes1) {
                    switch (tipe.getTpeCodigo()) {
                        case 1:
                            estima.setM1(false);
                            estima.setTip1(tipe);
                            break;
                        case 2:
                            estima.setM2(false);
                            estima.setTip2(tipe);
                            break;
                        case 3:
                            estima.setM3(false);
                            estima.setTip3(tipe);
                            break;
                        case 4:
                            estima.setM4(false);
                            estima.setTip4(tipe);
                            break;
                        case 5:
                            estima.setM5(false);
                            estima.setTip5(tipe);
                            break;
                        case 6:
                            estima.setM6(false);
                            estima.setTip6(tipe);
                            break;
                    }
                }
                estima.setRang(ran);
                listaEstimacionParticipantes.add(estima);
            }
            //Agregar Ingresos
            listaIngresos2.clear();
            listaIngresos2 = listaIngresos1;
        } catch (Exception e) {
        }



        return null;
    }

    public String eliminarRango() {
        listaRangos.remove(rangoSeleccionado);
        return null;
    }

    public String eliminarPreEvento() {
        if (preEventoSeleccionado.getPreEstado().equals("INICIADO")) {
            try {
                preEventoSeleccionado.setPreActivo(false);
                delegate.actualizar(preEventoSeleccionado);
            } catch (Exception ex) {
            }
        } else {
            mostrarMensaje("Error", "Solo se pueden Eliminar PreEventos con estado INICIADO", FacesMessage.SEVERITY_ERROR);
        }

        listarPreeventos();
        return "";
    }

    public String actualizarDetalle() {
        try {
            if (validarStrings(preEventoSeleccionado.getPreNombre())) {
                if (validarFechas(preEventoSeleccionado.getPrefechaInicio(), preEventoSeleccionado.getPrefechaFin())) {
                    delegate.actualizar(preEventoSeleccionado);
                    mostrarMensaje("Exito: ", "Se actualizo Correctamnete.", FacesMessage.SEVERITY_INFO);
                    return "";
                } else {
                    mostrarMensaje("Error: ", "Ingrese la Fecha Inicio y Fin Correctamente", FacesMessage.SEVERITY_ERROR);
                    return "";
                }

            } else {
                mostrarMensaje("Error: ", "Ingrese Nombre del Evento.", FacesMessage.SEVERITY_ERROR);
                return "";
            }

        } catch (Exception e) {
        }
        return "";
    }

//<editor-fold defaultstate="collapsed" desc="Agregar Modulo Curso e Instructores (LIZARDO)">
    public String agregarModuloSeleccionado() {
        for (CalendarioAmbientesAdapter cal : listaCalendario) {
            if (cal.getReservar()) {
                cal.setFecha(fechaAmbiente);
                listaCalendario1.add(cal);
            }

        }
        for (CalendarioAmbientesAdapter cal : listaCalendario1) {
            listaCalendario.remove(cal);
        }

        return "";
    }

    public String registrarModulo() {
        try {
            if (verificar()) {
                //System.out.println("codCurso: " + preEvento.getPreCodigo());
                //curso.setEveCodigo(preEvento.getPreCodigo());
                //modulo.setCurCodigo(curso);
                modulo.setModTemario(temarioModulo);

                //<editor-fold defaultstate="collapsed" desc="Probando modulo...">
                System.out.println("DATOS");
                System.out.println("-----");
                System.out.println("modCodigo: " + modulo.getModCodigo());
                System.out.println("modModulo: " + modulo.getModAcronimo());
                System.out.println("modNombre: " + modulo.getModNombre());
                System.out.println("modTipo: " + modulo.getModTipo());
                System.out.println("modPeriodo: " + modulo.getPeriodo());
                // // </editor-fold>
                //delegadoModulo.create(modulo);
                listaModulo.add(modulo);
                modulo =
                        new ModuloCurso();
                System.out.println("Lista Modulo - cantidad: " + listaModulo.size());
            }
//            agregarModulos();

        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "No se puede agregar módulo. ", FacesMessage.SEVERITY_ERROR);
            mostrarMensaje("FATAL: ", ex.getMessage(), FacesMessage.SEVERITY_FATAL);
        }

        return null;
    }

    public String agregarModulos() {
//        try {
//            modulo = new ModuloCurso();
//            ModuloCursoDelegate delegadoModulo = new ModuloCursoDelegate();
//            listaModulo = new ArrayList<ModuloCurso>();
//            listaModulo = delegadoModulo.listarModuloXCurso(preEvento.getPreCodigo());
//            delegadoModulo = null;
//        } catch (Exception ex) {
//            mostrarMensaje("ERROR: ", "No se puede listar módulos. ", FacesMessage.SEVERITY_ERROR);
//            mostrarMensaje("FATAL: ", ex.getMessage(), FacesMessage.SEVERITY_FATAL);
//        }
//        return "nuevo_modulo";
        return null;
    }

    public boolean verificar() {
        if (verificarNumeroModulos()) {
            if (verificarFechas()) {
                if (verificarRangoFechas()) {
                    return true;
                }

            }
        }
        return false;
    }

    public boolean verificarFechas() {
        Date fechaFinX = modulo.getModfechaFin();
        Date fechaInicioX = modulo.getModfechaInicio();
        //DATE.compareTo devuelve 1 si la fecha inicial es menor a la final
        //               devuelve -1 si la fecha inicial es mayor a la final
        //               devuelve 0 si ambas fechas son iguales
        int resultado = fechaFinX.compareTo(fechaInicioX);
        if (resultado == -1) {
            mostrarMensaje("ERROR: ", "La fecha de inicio no puede ser mayor que la fecha fin", FacesMessage.SEVERITY_ERROR);
            return false;
        }

        return true;
    }

    public boolean verificarRangoFechas() {
        try {
            int resultado;
            if (preEvento != null) {
                Date fechaInicioP = preEvento.getPrefechaInicio();
                Date fechaFinP = preEvento.getPrefechaFin();
                if (modulo != null) {
                    Date fechaInicioX = modulo.getModfechaInicio();
                    Date fechaFinX = modulo.getModfechaFin();
                    resultado =
                            fechaInicioX.compareTo(fechaInicioP);
                    if (resultado < 0) {
                        mostrarMensaje("ERROR: ", "Fecha de Inicio del módulo fuera del rango de fechas del Curso!", FacesMessage.SEVERITY_ERROR);
                        return false;
                    }

                    resultado = fechaInicioX.compareTo(fechaFinP);
                    if (resultado > 0) {
                        mostrarMensaje("ERROR: ", "Fecha de Inicio del módulo fuera del rango de fechas del Curso!", FacesMessage.SEVERITY_ERROR);
                        return false;
                    }

                    resultado = fechaFinX.compareTo(fechaInicioP);
                    if (resultado < 0) {
                        mostrarMensaje("ERROR: ", "Fecha Fin del Módulo fuera del rango de fechas del Curso!", FacesMessage.SEVERITY_ERROR);
                        return false;
                    }

                    resultado = fechaFinX.compareTo(fechaFinP);
                    if (resultado > 0) {
                        mostrarMensaje("ERROR: ", "Fecha Fin del Módulo fuera del rango de fechas del Curso!", FacesMessage.SEVERITY_ERROR);
                        return false;
                    }

                } else {
                    mostrarMensaje("ERROR: ", "No existen fechas del Módulo!", FacesMessage.SEVERITY_ERROR);
                    return false;
                }

            } else {
                mostrarMensaje("ERROR: ", "No existen fechas del Pre-evento!", FacesMessage.SEVERITY_ERROR);
                return false;
            }

        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "Error al verificar Rangos de Fechas.", FacesMessage.SEVERITY_ERROR);
            mostrarMensaje("FATAL: ", ex.getMessage(), FacesMessage.SEVERITY_FATAL);
        }

        return true;
    }

    public boolean verificarNumeroModulos() {
        try {
            int nroModuloI = (listaModulo == null) ? 0 : listaModulo.size();
            if (nroModulos == 0) {
                mostrarMensaje("ERROR: ", "Ingrese una cantidad de módulos mayor a cero!", FacesMessage.SEVERITY_ERROR);
                return false;
            }

            if (nroModulos <= nroModuloI) {
                mostrarMensaje("ERROR: ", "Solo puede ingresar hasta " + nroModulos + " módulos!", FacesMessage.SEVERITY_ERROR);
                return false;
            }

        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "No se puede verificar Numeros de módulos. ", FacesMessage.SEVERITY_ERROR);
            mostrarMensaje("FATAL: ", ex.getMessage(), FacesMessage.SEVERITY_FATAL);
        }

        return true;
    }

    public String eliminarModulo() {
        try {
            for (int i = 0; i <
                    listaModulo.size(); i++) {
                if (listaModulo.get(i).getModCodigo() == modulo.getModCodigo() &&
                        listaModulo.get(i).getModAcronimo().compareTo(modulo.getModAcronimo()) == 0 &&
                        listaModulo.get(i).getModNombre().compareTo(modulo.getModNombre()) == 0 &&
                        listaModulo.get(i).getModTipo() == modulo.getModTipo() &&
                        listaModulo.get(i).getModfechaInicio() == modulo.getModfechaInicio() &&
                        listaModulo.get(i).getModfechaFin() == modulo.getModfechaFin() &&
                        listaModulo.get(i).getModTemario().compareTo(modulo.getModTemario()) == 0) {
                    listaModulo.remove(i);
                    break;

                }


            }
            modulo = new ModuloCurso();
        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "No se pudo eliminar el módulo. ", FacesMessage.SEVERITY_ERROR);
            mostrarMensaje("FATAL: ", ex.getMessage(), FacesMessage.SEVERITY_FATAL);
        }

        return null;
    }

    public String verInstructores() {
        instructorModulo = new InstructorModulo();
        listaInstructorModulo =
                new ArrayList<InstructorModulo>();
        System.out.println(modulo.getModCodigo());
        //falta recorrer la lista
        //listaInstructorModulo = delegadoInstructorModulo.listarInstructorModulo(modulo.getModCodigo());
        return null;
    }

    //lizardo was here
    public String registrarInstructorEvento() {
        if (listaInstructores.size() > 0) {
        } else {
            mostrarMensaje("ERROR: ", "Debe existir por lo menos un instructor", FacesMessage.SEVERITY_ERROR);
            return null;
        }
        //Registrar Instructores
        PersonaNaturalDelegate delegatePersonaN = new PersonaNaturalDelegate();
        for (InstructorEvento ins : listaInstructores) {
            ins.setPreCodigo(preEventoSeleccionado);
            Integer insCodigo = ins.getIneCodigo();
            Integer preCodigo = preEventoSeleccionado.getPreCodigo();
            try {
                if (!delegateInstructor.estaRegistrado(insCodigo, preCodigo)) {
                    try {
                        if (ins.isRegistrado()) {
                            System.out.println("--If");
                            ins.setPerCodigo(delegatePersonaN.buscarXDNI(ins.getPerCodigo().getPerNroDNI()));
                        } else {
                            System.out.println("--else");
                            delegatePersonaN.registrar(ins.getPerCodigo());
                        }
                    } catch (Exception e) {
                        delegatePersonaN.registrar(ins.getPerCodigo());
                    }
                    ins.setInenroHoras(0); //inicialmente no tiene horas
                    ins.setInePrioridad(false); //inicialmente no tiene prioridad
                    System.out.println("REVISANDO DATOS DEL INSTRUCTOR");
                    System.out.println("------------------------------");
                    System.out.println("ineCodigo: " + ins.getIneCodigo());
                    System.out.println("preCodigo: " + ins.getPreCodigo());
                    System.out.println("perCodigo: " + ins.getPerCodigo());
                    System.out.println("inePrioridad: " + ins.getInePrioridad());
                    try {
                        delegateInstructor.registrar(ins);
                    } catch (Exception ex) {
                        mostrarMensaje("ERROR: ", "No se puede registrar al instructor", FacesMessage.SEVERITY_ERROR);
                        System.out.println("FATAL: " + ex.getMessage());
                        return null;
                    }
                }
            } catch (Exception ex) {
                mostrarMensaje("ERROR: ", "No se puede verificar si el instructor esta registrado", FacesMessage.SEVERITY_ERROR);
                System.out.println("FATAL: " + ex.getMessage());
                return null;
            }
        }
        mostrarMensaje("INFO: ", "Se modifico con exito al instructor", FacesMessage.SEVERITY_INFO);
        return null;
    }

    public String registrarInstructor() {
        try {
            //modulo.setModCodigo(modCodigo);
            System.out.println("ineCodigo: " + ineCodigo);
//            instructor = delegadoInstructorEvento.find(ineCodigo);
//            instructorModulo.setIneCodigo(instructor);
//            instructorModulo.setModCodigo(modulo);
            System.out.println("DATOS");
            System.out.println("-----");
            System.out.println("modulo: " + modulo);
//            System.out.println("instructor: " + instructor);
//            System.out.println("inmCodigo: " + instructorModulo.getInmCodigo());
//            System.out.println("modCodigo: " + instructorModulo.getModCodigo().getModCodigo());
//            System.out.println("ineCodigo: " + instructorModulo.getIneCodigo().getIneCodigo());
//            delegadoInstructorModulo.create(instructorModulo);
        } catch (Exception ex) {
            mostrarMensaje("ERROR: ", "No se puede agregar instructor. " + ex.getMessage(), FacesMessage.SEVERITY_ERROR);
        }

        verInstructores();
        return null;
    }

    public String eliminarInstructor() {
        //Aqui hay un adapter por eso primero se busca el objeto y luego se ejecuta la accion
//        instructorModulo = delegadoInstructorModulo.buscarXCodigo(instructorModuloAdapter.getCodigo());
//        System.out.println("Objeto instructor: " + instructorModulo.getIneCodigo());
//        System.out.println("Objeto modulo: " + instructorModulo.getModCodigo());
//        delegadoInstructorModulo.remove(instructorModulo);
//        listaInstructorModulo = delegadoInstructorModulo.listarInstructorModulo(cursoAdapter.getCodigo());
//        instructorModulo = new InstructorModulo();
        return null;
    }

    public SelectItem[] getComboInstructorEventos() {
        try {
            System.out.println("Ingreso 1");
            Integer curCodigo = curso.getEveCodigo();
            System.out.println("curCodigo: " + curCodigo);
            SelectItem[] selects = null;
            //List<InstructorEvento> listaInstructorEvento = delegadoInstructorEvento.listarInstructorEvento(curCodigo);
//            selects = new SelectItem[listaInstructorEvento.size()];
//            int cont = 0;
//            for (InstructorEvento instructorEvento : listaInstructorEvento) {
//                SelectItem item = new SelectItem(instructorEvento.getCodigo(), instructorEvento.getNombreCompleto());
//                selects[cont++] = item;
//            }
            return selects;
        } catch (Exception e) {
            System.out.println("Ingreso Error: " + e.getMessage());
            SelectItem[] selects = new SelectItem[1];
            SelectItem item = new SelectItem(null, "No existen Instructores");
            selects[0] = item;
            return selects;
        }
    }
    // // </editor-fold>

    public String cancelarInstructor() {
        return "retornarins";
    }

    public String cancelarPresupuesto() {
        return "retornarpre";
    }

    //Lizardo estuvo aqui
//    private String verificarTipo() {
//        String tipo;
//        try {
//            TipoEvento tipoEvento = new TipoEvento();
//            TipoEventoDelegate delegadoTipoEvento = new TipoEventoDelegate();
//            tipoEvento = delegadoTipoEvento.buscarTipoEvento(preEvento.getTevCodigo().getTevCodigo());
//            tipo = (tipoEvento.getTevTipo()==0) ? "EV" : "CU";
//            tipoEvento = null;
//            delegadoTipoEvento = null;
//            return tipo;
//        } catch (Exception ex) {
//            mostrarMensaje("ERROR:_", "En verificar tipo de evento", FacesMessage.SEVERITY_ERROR);
//            System.out.println("FATAL: " + ex.getMessage());
//            return "XX";
//        }
//    }

    private String verificarTipo() {
        String tipo = null;
        try {
            TipoEvento tipoEvento = new TipoEvento();
            TipoEventoDelegate delegadoTipoEvento = new TipoEventoDelegate();
            tipoEvento = delegadoTipoEvento.buscarTipoEvento(preEvento.getTevCodigo().getTevCodigo());
            if (tipoEvento != null) {
                if (tipoEvento.getTevTipo() != null) {
                    tipo = (tipoEvento.getTevTipo()==0) ? "EV" : "CU";
                }
                tipoEvento = null;
            }
            delegadoTipoEvento = null;
            return tipo;
        } catch (Exception ex) {
            mostrarMensaje("ERROR:_", "En verificar tipo de evento", FacesMessage.SEVERITY_ERROR);
            System.out.println("FATAL: " + ex.getMessage());
            return null;
        }
    }


    //CASTOR
     // subir archivo

    private UploadedFile upFile;
    boolean rendSuccess = false;
    boolean rendFailure = false;
    private String imagen;

    public boolean isRendFailure() {
        return rendFailure;
    }

    public void setRendFailure(boolean rendFailure) {
        this.rendFailure = rendFailure;
    }

    public boolean isRendSuccess() {
        return rendSuccess;
    }

    public void setRendSuccess(boolean rendSuccess) {
        this.rendSuccess = rendSuccess;
    }

    public UploadedFile getUpFile() {
        return upFile;
    }

    public void setUpFile(UploadedFile upFile) {
        this.upFile = upFile;
    }

    public String getImagen() {
        return imagen;
    }

    public void setImagen(String imagen) {
        this.imagen = imagen;
    }

    public String upload() throws IOException {

         try {                          
                rutaArchivo  = "D:\\Archivos\\";
                InputStream stream = upFile.getInputStream();
                rutaArchivo = rutaArchivo+upFile.getName();
                OutputStream out=new FileOutputStream(rutaArchivo);
                long size = upFile.getSize();
                byte[] buffer = new byte[(int) size];
                stream.read(buffer, 0, (int) size);
                out.write(buffer, 0, (int) size);
                stream.close();
                out.close();
                guardaArchivo();
                rendSuccess = true;
                rendFailure = false;
//                setImagen(upFile.getName());
                System.out.println("File Upload Successful.");
                return "ok";

        } catch (Exception ioe) {
            System.out.println("File Upload Unsuccessful.");
            System.out.println("errorrrr" + ioe.toString());
            rendSuccess = false;
            rendFailure = true;
            return "no";
        }
    }

    public String guardaArchivo(){
        try{
            Preevento Evento = new Preevento();
            if(preEventoSeleccionado.getPreCodigo() !=null){
                Evento = new Preevento();
                Evento = preEventoSeleccionado;
            }
            if(preEvento.getPreCodigo() != null){
                Evento = new Preevento();
                Evento = preEvento;
            }
            archivos = new Archivos();
            archivos.setAcrnombreArchivo(nombreArchivo);
            archivos.setArctipoArchivo(tipoArchivo);
            archivos.setPreCodigo(Evento.getPreCodigo());
            archivos.setAcrrutaArchivo(rutaArchivo);
            archivos.setArcFechaRegistro(new Date());            

            delegadoArchivos.create(archivos);
            
            rutaArchivo  = "D:\\Archivos\\";
//            rutaArchivo = "/modulos/eventos/archivos/";
            listarContenidoPresupuesto();
            archivos = new Archivos();
            

            return null;
        }catch(Exception ex){
            return null;
        }
    }

    public String removerArchivo(){

        try{
            File fichero = new File(archivos.getAcrrutaArchivo());
            
            if(fichero.delete()){
                mostrarMensaje("Exito: ", "Se elimino el archivo Correctamnete.", FacesMessage.SEVERITY_INFO);
            }else{
                mostrarMensaje("ERROR: ", "No se pudo eliminar el archivo", FacesMessage.SEVERITY_ERROR);
            }

            delegadoArchivos.remove(archivos);
            archivos = new Archivos();
            listarContenidoPresupuesto();

            return null;
        }catch(Exception ex){
            return null;
        }
    }

    public List<Archivos> listarContenidoPresupuesto(){

        try {
            Preevento Evento = new Preevento();
            if(preEventoSeleccionado.getPreCodigo() !=null){
                Evento = new Preevento();
                Evento = preEventoSeleccionado;
            }
            if(preEvento.getPreCodigo() != null){
                Evento = new Preevento();
                Evento = preEvento;
            }
            listaContenidoPresupuesto = new ArrayList<Archivos>();
            listaContenidoPresupuesto = delegadoArchivos.listaContPresup(Evento.getPreCodigo());
            return listaContenidoPresupuesto;

        } catch (Exception ex) {
            return null;
        }
    }

    public String mostrarArchivo() {
        try {
            System.out.println("ruta doc: "+archivos.getAcrrutaArchivo());
            File file = new File(archivos.getAcrrutaArchivo());
            FacesContext fcontext = FacesContext.getCurrentInstance();
            ExternalContext eContext = fcontext.getExternalContext();
            HttpServletResponse response = (HttpServletResponse) eContext.getResponse();
            response.setHeader("Content-Disposition", "inline; filename=" + file.getName());
            response.setHeader("Cache-Control", "public");
            response.setContentType("application/" + archivos.getAplication());
            OutputStream os = response.getOutputStream();
            FileInputStream inputStream = new FileInputStream(file);
            int tamanoInput = inputStream.available();
            byte[] datosPDF = new byte[tamanoInput];
            inputStream.read(datosPDF, 0, tamanoInput);
            os.write(datosPDF, 0, tamanoInput);
            os.close();
            fcontext.responseComplete();

        } catch (Exception e) {
            mostrarMensaje("Advertencia: ", "No se encontro el archivo", FacesMessage.SEVERITY_ERROR);
            return "";
        }
        return "";
    }

    public String retornarEvaluar(){

        return "retornarEvaluar";
    }

    public String ir_a_evaluar(){

        listarContenidoPresupuesto();
        return "ir_a_evaluar";
    }

    public String aprobarPreEvento() {
        try {
//            cargarEventosVerifPresupuesto();
//            if (preEventoSeleccionado.getPreAprobacion() == 2) {
                preEventoSeleccionado.setPreAprobacion(3);
                preEventoSeleccionado.setPreEstado("APROBADO");
                delegate.actualizar(preEventoSeleccionado);
                if (preEventoSeleccionado.getPreTipo().equals("EV")) {
                    //Guardar al Evento
                    Evento eve = new Evento();
                    eve.setEveCodigo(preEventoSeleccionado.getPreCodigo());
                    eve.setEveFecharegistro(new Date());
                    eve.setEveEstado(1);
                    eve.setPreevento(preEventoSeleccionado);
                    try {
                        delegateEvento.registrarEvento(eve);
                    } catch (Exception e) {
                        System.out.println("FATAL: " + e.getMessage());
                    }
                } else {
                    //Guardar Curso
                    Curso cur = new Curso();
                    cur.setEveCodigo(preEventoSeleccionado.getPreCodigo());
                    if (preEventoSeleccionado.getPreNroModulos() != null) {
                        cur.setCurnroSesiones(preEventoSeleccionado.getPreNroModulos());
                    } else  {
                        cur.setCurnroSesiones(0);
                    }
                    if (preEventoSeleccionado.getPreVacanteTemporal() != null) {
                        cur.setCurVacantes(preEventoSeleccionado.getPreVacanteTemporal());
                    } else {
                        cur.setCurVacantes(0);
                    }
                    cur.setCurfaltaMax(0);
                    cur.setEveEstado(1);
                    cur.setCurNotaMinima(0.0);
                    cur.setEveFecharegistro(new Date());
                    try {
                        delegateCurso.create(cur);
                    } catch (Exception e) {
                        System.out.println("FATAL: " + e.getMessage());
                    }
                }
//                inicializar();
//            } else {
//                preEventoSeleccionado.setPreAprobacion(1);
//                delegate.actualizar(preEventoSeleccionado);
//                inicializar();
//            }
//            inicializar();
            cargarEventosAprobados();
            return "retornarEvaluar";
        } catch (Exception e) {
            preEventoSeleccionado.setPreAprobacion(1);
            try {
                delegate.actualizar(preEventoSeleccionado);
            } catch (Exception ex) {
                Logger.getLogger(PreEventoController.class.getName()).log(Level.SEVERE, null, ex);
            }
            inicializar();
        }

        return "";
    }
    //FIN CASTOR
}
